#pragma once

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

// Package: FortniteGame

#include "Basic.hpp"

#include "FortniteGame_classes.hpp"
#include "FortniteGame_parameters.hpp"


#pragma pack(push, 0x4)
namespace SDK
{

// Function FortniteGame.AIHotSpot.AssignFromWaitingList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::AssignFromWaitingList()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "AssignFromWaitingList");

	Params::AIHotSpot_AssignFromWaitingList Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.AssignGroupToHotspot
// (Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class AAIController*>&     GroupOfAI                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::AssignGroupToHotspot(const TArray<class AAIController*>& GroupOfAI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "AssignGroupToHotspot");

	Params::AIHotSpot_AssignGroupToHotspot Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.AssignToHotspot
// (Native, Public, BlueprintCallable)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::AssignToHotspot(class AAIController* AI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "AssignToHotspot");

	Params::AIHotSpot_AssignToHotspot Parms{};

	Parms.AI = AI;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.AssignToSlotByIndex
// (Native, Public, BlueprintCallable)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::AssignToSlotByIndex(class AAIController* AI, int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "AssignToSlotByIndex");

	Params::AIHotSpot_AssignToSlotByIndex Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.AssignToSlotByUserId
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::AssignToSlotByUserId(class AAIController* AI, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "AssignToSlotByUserId");

	Params::AIHotSpot_AssignToSlotByUserId Parms{};

	Parms.AI = AI;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OccupySlotByIndex
// (Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OccupySlotByIndex(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OccupySlotByIndex");

	Params::AIHotSpot_OccupySlotByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OccupySlotByOwner
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OccupySlotByOwner(const class AAIController* AIOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OccupySlotByOwner");

	Params::AIHotSpot_OccupySlotByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OccupySlotByUserId
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OccupySlotByUserId(int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OccupySlotByUserId");

	Params::AIHotSpot_OccupySlotByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OnAssignedClaimedBehavior
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasOnWaitingList                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OnAssignedClaimedBehavior(class AAIController* AI, int32 INDEX, int32 UserId, bool bWasOnWaitingList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnAssignedClaimedBehavior");

	Params::AIHotSpot_OnAssignedClaimedBehavior Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;
	Parms.bWasOnWaitingList = bWasOnWaitingList;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OnAssignedOccupiedBehavior
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OnAssignedOccupiedBehavior(class AAIController* AI, int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnAssignedOccupiedBehavior");

	Params::AIHotSpot_OnAssignedOccupiedBehavior Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OnAssignedSlotlessBehavior
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::OnAssignedSlotlessBehavior(class AAIController* AI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnAssignedSlotlessBehavior");

	Params::AIHotSpot_OnAssignedSlotlessBehavior Parms{};

	Parms.AI = AI;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.OnHotSpotDisabled
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)

void AAIHotSpot::OnHotSpotDisabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnHotSpotDisabled");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnHotSpotEnabled
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)

void AAIHotSpot::OnHotSpotEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnHotSpotEnabled");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnMoveToSlotFinished
// (BlueprintAuthorityOnly, Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AAIHotSpot::OnMoveToSlotFinished(class AAIController* AI, int32 INDEX, int32 UserId, bool bResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnMoveToSlotFinished");

	Params::AIHotSpot_OnMoveToSlotFinished Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;
	Parms.bResult = bResult;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnRemovedBehavior
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          PrevState                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWasOnWaitingList                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AAIHotSpot::OnRemovedBehavior(class AAIController* AI, int32 INDEX, int32 UserId, EAIHotSpotSlot PrevState, bool bWasOnWaitingList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnRemovedBehavior");

	Params::AIHotSpot_OnRemovedBehavior Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;
	Parms.PrevState = PrevState;
	Parms.bWasOnWaitingList = bWasOnWaitingList;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnRemovedSlotlessBehavior
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsClamingSlot                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AAIHotSpot::OnRemovedSlotlessBehavior(class AAIController* AI, bool bIsClamingSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnRemovedSlotlessBehavior");

	Params::AIHotSpot_OnRemovedSlotlessBehavior Parms{};

	Parms.AI = AI;
	Parms.bIsClamingSlot = bIsClamingSlot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotBlocked
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotBlocked(class AAIController* AI, int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotBlocked");

	Params::AIHotSpot_OnSlotBlocked Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotClaimed
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotClaimed(class AAIController* AI, int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotClaimed");

	Params::AIHotSpot_OnSlotClaimed Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotDisabled
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotDisabled(int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotDisabled");

	Params::AIHotSpot_OnSlotDisabled Parms{};

	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotEnabled
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotEnabled(int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotEnabled");

	Params::AIHotSpot_OnSlotEnabled Parms{};

	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotFreed
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotFreed(class AAIController* AI, int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotFreed");

	Params::AIHotSpot_OnSlotFreed Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.OnSlotOccupied
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AAIHotSpot::OnSlotOccupied(class AAIController* AI, int32 INDEX, int32 UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "OnSlotOccupied");

	Params::AIHotSpot_OnSlotOccupied Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.RemoveFromHotspot
// (Native, Public, BlueprintCallable)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAssignFromWaitingList                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::RemoveFromHotspot(class AAIController* AI, bool bAssignFromWaitingList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "RemoveFromHotspot");

	Params::AIHotSpot_RemoveFromHotspot Parms{};

	Parms.AI = AI;
	Parms.bAssignFromWaitingList = bAssignFromWaitingList;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.RemoveGroupFromHotspot
// (Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class AAIController*>&     GroupOfAI                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::RemoveGroupFromHotspot(const TArray<class AAIController*>& GroupOfAI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "RemoveGroupFromHotspot");

	Params::AIHotSpot_RemoveGroupFromHotspot Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.SetEnabled
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AAIHotSpot::SetEnabled(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "SetEnabled");

	Params::AIHotSpot_SetEnabled Parms{};

	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpot.CanUseSlotByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AI                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::CanUseSlotByIndex(const class AAIController* AI, int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "CanUseSlotByIndex");

	Params::AIHotSpot_CanUseSlotByIndex Parms{};

	Parms.AI = AI;
	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.CanUseSlotByUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AI                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::CanUseSlotByUserId(const class AAIController* AI, int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "CanUseSlotByUserId");

	Params::AIHotSpot_CanUseSlotByUserId Parms{};

	Parms.AI = AI;
	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.FindBestSlotIndex
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AAIController*                    AI                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::FindBestSlotIndex(class AAIController* AI) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "FindBestSlotIndex");

	Params::AIHotSpot_FindBestSlotIndex Parms{};

	Parms.AI = AI;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.FindBestSlotIndices
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class AAIController*>&     AI                                                     (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<int32>                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<int32> AAIHotSpot::FindBestSlotIndices(const TArray<class AAIController*>& AI) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "FindBestSlotIndices");

	Params::AIHotSpot_FindBestSlotIndices Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetAssignedAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIHotSpotAssignmentFilter              Filter                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AAIController*>            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AAIController*> AAIHotSpot::GetAssignedAI(EAIHotSpotAssignmentFilter Filter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetAssignedAI");

	Params::AIHotSpot_GetAssignedAI Parms{};

	Parms.Filter = Filter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetAssignedAICount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIHotSpotAssignmentFilter              Filter                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetAssignedAICount(EAIHotSpotAssignmentFilter Filter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetAssignedAICount");

	Params::AIHotSpot_GetAssignedAICount Parms{};

	Parms.Filter = Filter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIHotSpotSlot*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIHotSpotSlot* AAIHotSpot::GetSlotByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotByIndex");

	Params::AIHotSpot_GetSlotByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotByOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIHotSpotSlot*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIHotSpotSlot* AAIHotSpot::GetSlotByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotByOwner");

	Params::AIHotSpot_GetSlotByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotByUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAIHotSpotSlot*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIHotSpotSlot* AAIHotSpot::GetSlotByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotByUserId");

	Params::AIHotSpot_GetSlotByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIHotSpotSlotFilter                    Filter                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetSlotCount(EAIHotSpotSlotFilter Filter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotCount");

	Params::AIHotSpot_GetSlotCount Parms{};

	Parms.Filter = Filter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotIndexByOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetSlotIndexByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotIndexByOwner");

	Params::AIHotSpot_GetSlotIndexByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotIndexByUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetSlotIndexByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotIndexByUserId");

	Params::AIHotSpot_GetSlotIndexByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotLocationByIndex
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AAIHotSpot::GetSlotLocationByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotLocationByIndex");

	Params::AIHotSpot_GetSlotLocationByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotLocationByOwner
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AAIHotSpot::GetSlotLocationByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotLocationByOwner");

	Params::AIHotSpot_GetSlotLocationByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotLocationByUserId
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AAIHotSpot::GetSlotLocationByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotLocationByUserId");

	Params::AIHotSpot_GetSlotLocationByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotOwnerByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AAIController*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIController* AAIHotSpot::GetSlotOwnerByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotOwnerByIndex");

	Params::AIHotSpot_GetSlotOwnerByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotOwnerByUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AAIController*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIController* AAIHotSpot::GetSlotOwnerByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotOwnerByUserId");

	Params::AIHotSpot_GetSlotOwnerByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotRotationByIndex
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AAIHotSpot::GetSlotRotationByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotRotationByIndex");

	Params::AIHotSpot_GetSlotRotationByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotRotationByOwner
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AAIHotSpot::GetSlotRotationByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotRotationByOwner");

	Params::AIHotSpot_GetSlotRotationByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotRotationByUserId
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AAIHotSpot::GetSlotRotationByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotRotationByUserId");

	Params::AIHotSpot_GetSlotRotationByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotStateByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIHotSpotSlot AAIHotSpot::GetSlotStateByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotStateByIndex");

	Params::AIHotSpot_GetSlotStateByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotStateByOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIHotSpotSlot AAIHotSpot::GetSlotStateByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotStateByOwner");

	Params::AIHotSpot_GetSlotStateByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotStateByUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   UserId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIHotSpotSlot AAIHotSpot::GetSlotStateByUserId(int32 UserId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotStateByUserId");

	Params::AIHotSpot_GetSlotStateByUserId Parms{};

	Parms.UserId = UserId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotUserIdByIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetSlotUserIdByIndex(int32 INDEX) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotUserIdByIndex");

	Params::AIHotSpot_GetSlotUserIdByIndex Parms{};

	Parms.INDEX = INDEX;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.GetSlotUserIdByOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AIOwner                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AAIHotSpot::GetSlotUserIdByOwner(const class AAIController* AIOwner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "GetSlotUserIdByOwner");

	Params::AIHotSpot_GetSlotUserIdByOwner Parms{};

	Parms.AIOwner = AIOwner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.HasAssignedAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AAIController*              AI                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotAssignmentFilter              Filter                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::HasAssignedAI(const class AAIController* AI, EAIHotSpotAssignmentFilter Filter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "HasAssignedAI");

	Params::AIHotSpot_HasAssignedAI Parms{};

	Parms.AI = AI;
	Parms.Filter = Filter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.HasEnabledSlots
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::HasEnabledSlots() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "HasEnabledSlots");

	Params::AIHotSpot_HasEnabledSlots Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.IsAIAllowed
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AAIController*              AI                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::IsAIAllowed(const class AAIController* AI) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "IsAIAllowed");

	Params::AIHotSpot_IsAIAllowed Parms{};

	Parms.AI = AI;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "IsEnabled");

	Params::AIHotSpot_IsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpot.IsSlotlessAssignmentAllowed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AAIHotSpot::IsSlotlessAssignmentAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpot", "IsSlotlessAssignmentAllowed");

	Params::AIHotSpot_IsSlotlessAssignmentAllowed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuickBars.Empty
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortQuickBars::Empty(EFortQuickBars InQuickBar)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "Empty");

	Params::FortQuickBars_Empty Parms{};

	Parms.InQuickBar = InQuickBar;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.OnRep_PrimaryQuickBar
// (Final, Native, Private)

void AFortQuickBars::OnRep_PrimaryQuickBar()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "OnRep_PrimaryQuickBar");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.OnRep_SecondaryQuickBar
// (Final, Native, Private)

void AFortQuickBars::OnRep_SecondaryQuickBar()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "OnRep_SecondaryQuickBar");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.ServerActivateSlotInternal
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AcivateDelay                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortQuickBars::ServerActivateSlotInternal(EFortQuickBars InQuickBar, int32 Slot, float AcivateDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "ServerActivateSlotInternal");

	Params::FortQuickBars_ServerActivateSlotInternal Parms{};

	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;
	Parms.AcivateDelay = AcivateDelay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.ServerAddItemInternal
// (Final, Net, NetReliable, Native, Event, Private, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortQuickBars::ServerAddItemInternal(const struct FGuid& Item, EFortQuickBars InQuickBar, int32 Slot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "ServerAddItemInternal");

	Params::FortQuickBars_ServerAddItemInternal Parms{};

	Parms.Item = std::move(Item);
	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.ServerRemoveItemInternal
// (Final, Net, NetReliable, Native, Event, Private, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bFindReplacement                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortQuickBars::ServerRemoveItemInternal(const struct FGuid& Item, bool bFindReplacement, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "ServerRemoveItemInternal");

	Params::FortQuickBars_ServerRemoveItemInternal Parms{};

	Parms.Item = std::move(Item);
	Parms.bFindReplacement = bFindReplacement;
	Parms.bForce = bForce;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuickBars.ServerSwapItemsInternal
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// EFortQuickBars                          QuickBarA                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIndexA                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortQuickBars                          QuickBarB                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIndexB                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortQuickBars::ServerSwapItemsInternal(EFortQuickBars QuickBarA, int32 SlotIndexA, EFortQuickBars QuickBarB, int32 SlotIndexB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuickBars", "ServerSwapItemsInternal");

	Params::FortQuickBars_ServerSwapItemsInternal Parms{};

	Parms.QuickBarA = QuickBarA;
	Parms.SlotIndexA = SlotIndexA;
	Parms.QuickBarB = QuickBarB;
	Parms.SlotIndexB = SlotIndexB;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AccumulatedGameplayEffectInfo.GetRelativeEffectAtRating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             NewRating                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayEffectInfo              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayEffectInfo UAccumulatedGameplayEffectInfo::GetRelativeEffectAtRating(const int32 NewRating) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AccumulatedGameplayEffectInfo", "GetRelativeEffectAtRating");

	Params::AccumulatedGameplayEffectInfo_GetRelativeEffectAtRating Parms{};

	Parms.NewRating = NewRating;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameMode.HandleScoreToXPUpdate
// (Native, Public)

void AFortGameMode::HandleScoreToXPUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameMode", "HandleScoreToXPUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameMode.DumpReservations
// (Exec, Native, Public, Const)

void AFortGameMode::DumpReservations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameMode", "DumpReservations");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortItemCollectedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UFortWorldItemDefinition**        _CollectedItemDefinition                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _CollectedBy                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  _AmountCollected                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCollectedParams::BreakData(class UFortWorldItemDefinition** _CollectedItemDefinition, class AFortPlayerController** _CollectedBy, int32* _AmountCollected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCollectedParams", "BreakData");

	Params::FortItemCollectedParams_BreakData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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


// Function FortniteGame.FortItemCollectedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UFortWorldItemDefinition*   _CollectedItemDefinition                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _CollectedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _AmountCollected                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItemCollectedParams**        ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCollectedParams::MakeData(const class UFortWorldItemDefinition* _CollectedItemDefinition, class AFortPlayerController* _CollectedBy, int32 _AmountCollected, class UFortItemCollectedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCollectedParams", "MakeData");

	Params::FortItemCollectedParams_MakeData Parms{};

	Parms._CollectedItemDefinition = _CollectedItemDefinition;
	Parms._CollectedBy = _CollectedBy;
	Parms._AmountCollected = _AmountCollected;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.WorldMapPin.OnTheaterIndexSet
// (Event, Public, BlueprintEvent)

void AWorldMapPin::OnTheaterIndexSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WorldMapPin", "OnTheaterIndexSet");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.WorldMapPin.SetTheaterIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   NewIndex                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AWorldMapPin::SetTheaterIndex(int32 NewIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WorldMapPin", "SetTheaterIndex");

	Params::WorldMapPin_SetTheaterIndex Parms{};

	Parms.NewIndex = NewIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlot.ClearSlot
// (Native, Public, BlueprintCallable)

void UAIHotSpotSlot::ClearSlot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "ClearSlot");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlot.OnStateChanged
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AAIController*                    SlotOwner                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIHotSpotSlot::OnStateChanged(class AAIController* SlotOwner, EAIHotSpotSlot NewState)
{
	static class UFunction* Func = nullptr;

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

	Params::AIHotSpotSlot_OnStateChanged Parms{};

	Parms.SlotOwner = SlotOwner;
	Parms.NewState = NewState;

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


// Function FortniteGame.AIHotSpotSlot.SetSlotEnabled
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewEnabled                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UAIHotSpotSlot::SetSlotEnabled(bool bNewEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "SetSlotEnabled");

	Params::AIHotSpotSlot_SetSlotEnabled Parms{};

	Parms.bNewEnabled = bNewEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlot.SetSlotOwnerAndState
// (Native, Public, BlueprintCallable)
// Parameters:
// class AAIController*                    NewOwner                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIHotSpotSlot                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIHotSpotSlot::SetSlotOwnerAndState(class AAIController* NewOwner, EAIHotSpotSlot NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "SetSlotOwnerAndState");

	Params::AIHotSpotSlot_SetSlotOwnerAndState Parms{};

	Parms.NewOwner = NewOwner;
	Parms.NewState = NewState;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlot.SetSlotState
// (Native, Public, BlueprintCallable)
// Parameters:
// EAIHotSpotSlot                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAIHotSpotSlot::SetSlotState(EAIHotSpotSlot NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "SetSlotState");

	Params::AIHotSpotSlot_SetSlotState Parms{};

	Parms.NewState = NewState;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlot.GetHotSpot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AAIHotSpot*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIHotSpot* UAIHotSpotSlot::GetHotSpot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetHotSpot");

	Params::AIHotSpotSlot_GetHotSpot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBox                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FBox UAIHotSpotSlot::GetSlotBounds() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotBounds");

	Params::AIHotSpotSlot_GetSlotBounds Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotHeight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIHotSpotSlot::GetSlotHeight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotHeight");

	Params::AIHotSpotSlot_GetSlotHeight Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

int32 UAIHotSpotSlot::GetSlotIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotIndex");

	Params::AIHotSpotSlot_GetSlotIndex Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UAIHotSpotSlot::GetSlotLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotLocation");

	Params::AIHotSpotSlot_GetSlotLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AAIController*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIController* UAIHotSpotSlot::GetSlotOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotOwner");

	Params::AIHotSpotSlot_GetSlotOwner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotRadius
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UAIHotSpotSlot::GetSlotRadius() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotRadius");

	Params::AIHotSpotSlot_GetSlotRadius Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UAIHotSpotSlot::GetSlotRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotRotation");

	Params::AIHotSpotSlot_GetSlotRotation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.GetSlotState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIHotSpotSlot                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIHotSpotSlot UAIHotSpotSlot::GetSlotState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotState");

	Params::AIHotSpotSlot_GetSlotState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

int32 UAIHotSpotSlot::GetSlotUserId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "GetSlotUserId");

	Params::AIHotSpotSlot_GetSlotUserId Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.HasUserId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UAIHotSpotSlot::HasUserId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "HasUserId");

	Params::AIHotSpotSlot_HasUserId Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.IsAIAllowed
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AAIController*              AI                                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UAIHotSpotSlot::IsAIAllowed(const class AAIController* AI) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "IsAIAllowed");

	Params::AIHotSpotSlot_IsAIAllowed Parms{};

	Parms.AI = AI;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlot.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UAIHotSpotSlot::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlot", "IsEnabled");

	Params::AIHotSpotSlot_IsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.ApplyGameplayEffectContainer
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayAbilityTargetDataHandle&TargetData                                             (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)
// int32                                   GameplayEffectLevel                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FActiveGameplayEffectHandle>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

const TArray<struct FActiveGameplayEffectHandle> UFortGameplayAbility::ApplyGameplayEffectContainer(const struct FGameplayAbilityTargetDataHandle& TargetData, const struct FGameplayTag& ApplicationTag, int32 GameplayEffectLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "ApplyGameplayEffectContainer");

	Params::FortGameplayAbility_ApplyGameplayEffectContainer Parms{};

	Parms.TargetData = std::move(TargetData);
	Parms.ApplicationTag = std::move(ApplicationTag);
	Parms.GameplayEffectLevel = GameplayEffectLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.ClearAIFocalPoint
// (Final, Native, Public, BlueprintCallable)

void UFortGameplayAbility::ClearAIFocalPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "ClearAIFocalPoint");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility.EquipAbilityWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortWeaponItemDefinition*        WeaponDefinition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGameplayAbility::EquipAbilityWeapon(class UFortWeaponItemDefinition* WeaponDefinition, int32 ItemLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "EquipAbilityWeapon");

	Params::FortGameplayAbility_EquipAbilityWeapon Parms{};

	Parms.WeaponDefinition = WeaponDefinition;
	Parms.ItemLevel = ItemLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility.GetAimLocationNearestPawn
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AFortPawn*                        Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortGameplayAbility::GetAimLocationNearestPawn(class AFortPawn* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetAimLocationNearestPawn");

	Params::FortGameplayAbility_GetAimLocationNearestPawn Parms{};

	Parms.Instigator = Instigator;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.K2_AbilityCompleted
// (Native, Public, BlueprintCallable)

void UFortGameplayAbility::K2_AbilityCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "K2_AbilityCompleted");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility.K2_TriggerFromAnimation
// (Event, Public, BlueprintEvent)
// Parameters:
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)

void UFortGameplayAbility::K2_TriggerFromAnimation(const struct FGameplayTag& ApplicationTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "K2_TriggerFromAnimation");

	Params::FortGameplayAbility_K2_TriggerFromAnimation Parms{};

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

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


// Function FortniteGame.FortGameplayAbility.MakeGameplayEffectContainerSpec
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)
// int32                                   GameplayEffectLevel                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortGameplayEffectContainerSpec ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortGameplayEffectContainerSpec UFortGameplayAbility::MakeGameplayEffectContainerSpec(const struct FGameplayTag& ApplicationTag, int32 GameplayEffectLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "MakeGameplayEffectContainerSpec");

	Params::FortGameplayAbility_MakeGameplayEffectContainerSpec Parms{};

	Parms.ApplicationTag = std::move(ApplicationTag);
	Parms.GameplayEffectLevel = GameplayEffectLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.OnAbilityInputReleased
// (Event, Protected, BlueprintEvent)

void UFortGameplayAbility::OnAbilityInputReleased()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "OnAbilityInputReleased");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortGameplayAbility.RemoveAbilityWeapon
// (Final, Native, Public, BlueprintCallable)

void UFortGameplayAbility::RemoveAbilityWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "RemoveAbilityWeapon");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility.SetAIFocalPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           FocusTarget                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   FocalPoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortGameplayAbility::SetAIFocalPoint(class AActor* FocusTarget, const struct FVector& FocalPoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "SetAIFocalPoint");

	Params::FortGameplayAbility_SetAIFocalPoint Parms{};

	Parms.FocusTarget = FocusTarget;
	Parms.FocalPoint = std::move(FocalPoint);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility.SetupIconOverride
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility::SetupIconOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "SetupIconOverride");

	Params::FortGameplayAbility_SetupIconOverride Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.ApplyAccuracyToTargetLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   SourceLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   inDesiredThrowAngle                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortGameplayAbility::ApplyAccuracyToTargetLocation(const struct FVector& SourceLocation, const struct FVector& TargetLocation, float inDesiredThrowAngle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "ApplyAccuracyToTargetLocation");

	Params::FortGameplayAbility_ApplyAccuracyToTargetLocation Parms{};

	Parms.SourceLocation = std::move(SourceLocation);
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.inDesiredThrowAngle = inDesiredThrowAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.DoesTargetHaveProhibitedTagsForAI
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility::DoesTargetHaveProhibitedTagsForAI(const class AActor* Target) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "DoesTargetHaveProhibitedTagsForAI");

	Params::FortGameplayAbility_DoesTargetHaveProhibitedTagsForAI Parms{};

	Parms.Target = Target;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.DoesTargetHaveTags
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Target                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     Tags                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility::DoesTargetHaveTags(const class AActor* Target, const struct FGameplayTagContainer& Tags) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "DoesTargetHaveTags");

	Params::FortGameplayAbility_DoesTargetHaveTags Parms{};

	Parms.Target = Target;
	Parms.Tags = std::move(Tags);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetActivatingAbilityComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAbilitySystemComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilitySystemComponent* UFortGameplayAbility::GetActivatingAbilityComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetActivatingAbilityComponent");

	Params::FortGameplayAbility_GetActivatingAbilityComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetActivatingPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPawn*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPawn* UFortGameplayAbility::GetActivatingPawn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetActivatingPawn");

	Params::FortGameplayAbility_GetActivatingPawn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetAIAbilityTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UFortGameplayAbility::GetAIAbilityTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetAIAbilityTarget");

	Params::FortGameplayAbility_GetAIAbilityTarget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetCurrentAbilitySource
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAbilitySourceType*                 OutSourceType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutSourceLevel                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGameplayAbility::GetCurrentAbilitySource(EFortAbilitySourceType* OutSourceType, int32* OutSourceLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetCurrentAbilitySource");

	Params::FortGameplayAbility_GetCurrentAbilitySource Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function FortniteGame.FortGameplayAbility.GetCurrentSourceItemDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorldItemDefinition* UFortGameplayAbility::GetCurrentSourceItemDefinition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetCurrentSourceItemDefinition");

	Params::FortGameplayAbility_GetCurrentSourceItemDefinition Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetCurrentSourceWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortWeapon*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortWeapon* UFortGameplayAbility::GetCurrentSourceWeapon() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetCurrentSourceWeapon");

	Params::FortGameplayAbility_GetCurrentSourceWeapon Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetCustomAbilitySourceTransform
// (Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UFortGameplayAbility::GetCustomAbilitySourceTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetCustomAbilitySourceTransform");

	Params::FortGameplayAbility_GetCustomAbilitySourceTransform Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetFireLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortGameplayAbility::GetFireLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetFireLocation");

	Params::FortGameplayAbility_GetFireLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetFireRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bApplyLeading                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bApplyInaccuracy                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bApplyClampedMaxYawAngleToFire                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UFortGameplayAbility::GetFireRotation(bool bApplyLeading, bool bApplyInaccuracy, bool bApplyClampedMaxYawAngleToFire) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetFireRotation");

	Params::FortGameplayAbility_GetFireRotation Parms{};

	Parms.bApplyLeading = bApplyLeading;
	Parms.bApplyInaccuracy = bApplyInaccuracy;
	Parms.bApplyClampedMaxYawAngleToFire = bApplyClampedMaxYawAngleToFire;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetGameplayEffectContainer
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FFortGameplayEffectContainer UFortGameplayAbility::GetGameplayEffectContainer(const struct FGameplayTag& ApplicationTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetGameplayEffectContainer");

	Params::FortGameplayAbility_GetGameplayEffectContainer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetProjectileInitialValues
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  outProjectileSpeed                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        outSpawnDirection                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  outProjectileGravity                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor**                          HomingTarget                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bApplyInaccuracy                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bApplyClampedMaxYawAngleToFire                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bApplyLeading                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortGameplayAbility::GetProjectileInitialValues(float* outProjectileSpeed, struct FRotator* outSpawnDirection, float* outProjectileGravity, class AActor** HomingTarget, bool bApplyInaccuracy, bool bApplyClampedMaxYawAngleToFire, bool bApplyLeading) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetProjectileInitialValues");

	Params::FortGameplayAbility_GetProjectileInitialValues Parms{};

	Parms.bApplyInaccuracy = bApplyInaccuracy;
	Parms.bApplyClampedMaxYawAngleToFire = bApplyClampedMaxYawAngleToFire;
	Parms.bApplyLeading = bApplyLeading;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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

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


// Function FortniteGame.FortGameplayAbility.GetTargetSelectionList
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)
// struct FFortAbilityTargetSelectionList  ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortAbilityTargetSelectionList UFortGameplayAbility::GetTargetSelectionList(const struct FGameplayTag& ApplicationTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetTargetSelectionList");

	Params::FortGameplayAbility_GetTargetSelectionList Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.GetTooltip
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UFortTooltip>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UFortTooltip> UFortGameplayAbility::GetTooltip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "GetTooltip");

	Params::FortGameplayAbility_GetTooltip Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.IsTargetOutsideOfMaxYawRotation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility::IsTargetOutsideOfMaxYawRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "IsTargetOutsideOfMaxYawRotation");

	Params::FortGameplayAbility_IsTargetOutsideOfMaxYawRotation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility.K2_ShouldUseDecoTool
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const struct FGameplayAbilityActorInfo& ActorInfo                                              (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility::K2_ShouldUseDecoTool(const struct FGameplayAbilityActorInfo& ActorInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility", "K2_ShouldUseDecoTool");

	Params::FortGameplayAbility_K2_ShouldUseDecoTool Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlotGenerator.GenerateSlots
// (Native, Event, Public, BlueprintEvent)

void UAIHotSpotSlotGenerator::GenerateSlots()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlotGenerator", "GenerateSlots");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.AIHotSpotSlotGenerator.AddSlot
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   RelativeLocation                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  RelativeRotation                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UAIHotSpotSlot>       CustomSlotClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// class UAIHotSpotSlot*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAIHotSpotSlot* UAIHotSpotSlotGenerator::AddSlot(const struct FVector& RelativeLocation, const struct FRotator& RelativeRotation, TSubclassOf<class UAIHotSpotSlot> CustomSlotClass, bool bEnabled) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlotGenerator", "AddSlot");

	Params::AIHotSpotSlotGenerator_AddSlot Parms{};

	Parms.RelativeLocation = std::move(RelativeLocation);
	Parms.RelativeRotation = std::move(RelativeRotation);
	Parms.CustomSlotClass = CustomSlotClass;
	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.AIHotSpotSlotGenerator.GetHotSpot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AAIHotSpot*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AAIHotSpot* UAIHotSpotSlotGenerator::GetHotSpot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AIHotSpotSlotGenerator", "GetHotSpot");

	Params::AIHotSpotSlotGenerator_GetHotSpot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCarriedObject.OnRep_HolderInfo
// (Native, Protected, HasOutParams)
// Parameters:
// struct FCarriedObjectAttachmentInfo*    PreviousInfo                                           (Parm, OutParm, NativeAccessSpecifierPublic)

void AFortCarriedObject::OnRep_HolderInfo(struct FCarriedObjectAttachmentInfo* PreviousInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObject", "OnRep_HolderInfo");

	Params::FortCarriedObject_OnRep_HolderInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortCarriedObject.ReturnToSpawnPoint
// (Final, Native, Public, BlueprintCallable)

void AFortCarriedObject::ReturnToSpawnPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObject", "ReturnToSpawnPoint");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCarriedObject.GetHoldingActor
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortCarriedObject::GetHoldingActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObject", "GetHoldingActor");

	Params::FortCarriedObject_GetHoldingActor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeatherAugment.GetWeatherTags
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagContainer      ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FGameplayTagContainer AFortWeatherAugment::GetWeatherTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeatherAugment", "GetWeatherTags");

	Params::FortWeatherAugment_GetWeatherTags Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCameraBase.Exhibit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortExhibitActor*                TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCameraBase::Exhibit(class AFortExhibitActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCameraBase", "Exhibit");

	Params::FortCameraBase_Exhibit Parms{};

	Parms.TargetActor = TargetActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCameraBase.OnActivated
// (Event, Public, BlueprintEvent)

void AFortCameraBase::OnActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCameraBase", "OnActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCameraBase.OnDeactivated
// (Event, Public, BlueprintEvent)

void AFortCameraBase::OnDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCameraBase", "OnDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCameraBase.OnDragBegin
// (Event, Public, BlueprintEvent)

void AFortCameraBase::OnDragBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCameraBase", "OnDragBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCameraBase.OnDragEnd
// (Event, Public, BlueprintEvent)

void AFortCameraBase::OnDragEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCameraBase", "OnDragEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortHomeBaseCamera.ClearBuildingFocus
// (Event, Public, BlueprintEvent)

void AFortHomeBaseCamera::ClearBuildingFocus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeBaseCamera", "ClearBuildingFocus");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortHomeBaseCamera.SetBuildingFocus
// (Event, Public, BlueprintEvent)
// Parameters:
// class UCameraComponent*                 BuildingCameraComponent                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortHomeBaseCamera::SetBuildingFocus(class UCameraComponent* BuildingCameraComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeBaseCamera", "SetBuildingFocus");

	Params::FortHomeBaseCamera_SetBuildingFocus Parms{};

	Parms.BuildingCameraComponent = BuildingCameraComponent;

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


// Function FortniteGame.FortHomeBaseCamera.LimitTo
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   DesiredPosition                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class APostProcessVolume*               Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortHomeBaseCamera::LimitTo(const struct FVector& DesiredPosition, class APostProcessVolume* Volume) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeBaseCamera", "LimitTo");

	Params::FortHomeBaseCamera_LimitTo Parms{};

	Parms.DesiredPosition = std::move(DesiredPosition);
	Parms.Volume = Volume;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBannerColor
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UMyTownLibrary::GetBannerColor(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBannerColor");

	Params::MyTownLibrary_GetBannerColor Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBannerPattern
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UMyTownLibrary::GetBannerPattern(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBannerPattern");

	Params::MyTownLibrary_GetBannerPattern Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBuildingActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingTemplateId                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AMyTownBuildingActor*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AMyTownBuildingActor* UMyTownLibrary::GetBuildingActor(class UObject* WorldContextObject, const class FString& BuildingTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBuildingActor");

	Params::MyTownLibrary_GetBuildingActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BuildingTemplateId = std::move(BuildingTemplateId);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBuildingDefinition
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingTemplateId                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMyTownBuildingDefinitionData*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMyTownBuildingDefinitionData* UMyTownLibrary::GetBuildingDefinition(class UObject* WorldContextObject, const class FString& BuildingTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBuildingDefinition");

	Params::MyTownLibrary_GetBuildingDefinition Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BuildingTemplateId = std::move(BuildingTemplateId);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBuildingLevel
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingTemplateId                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UMyTownLibrary::GetBuildingLevel(class UObject* WorldContextObject, const class FString& BuildingTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBuildingLevel");

	Params::MyTownLibrary_GetBuildingLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BuildingTemplateId = std::move(BuildingTemplateId);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetBuildingState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingTemplateId                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMyTownBuildingState                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMyTownBuildingState UMyTownLibrary::GetBuildingState(class UObject* WorldContextObject, const class FString& BuildingTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetBuildingState");

	Params::MyTownLibrary_GetBuildingState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.BuildingTemplateId = std::move(BuildingTemplateId);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetMyTownData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMyTownData*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMyTownData* UMyTownLibrary::GetMyTownData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetMyTownData");

	Params::MyTownLibrary_GetMyTownData Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetMyTownName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UMyTownLibrary::GetMyTownName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetMyTownName");

	Params::MyTownLibrary_GetMyTownName Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.GetRoadsInfo
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FMyTownRoadData3D>        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FMyTownRoadData3D> UMyTownLibrary::GetRoadsInfo(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "GetRoadsInfo");

	Params::MyTownLibrary_GetRoadsInfo Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.IsKeepAvailable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UMyTownLibrary::IsKeepAvailable(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "IsKeepAvailable");

	Params::MyTownLibrary_IsKeepAvailable Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.IsManorAvailable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UMyTownLibrary::IsManorAvailable(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "IsManorAvailable");

	Params::MyTownLibrary_IsManorAvailable Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.IsShowingFriendsHomeBase
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UMyTownLibrary::IsShowingFriendsHomeBase(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "IsShowingFriendsHomeBase");

	Params::MyTownLibrary_IsShowingFriendsHomeBase Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownLibrary.RegisterSlotCamera
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MapSlotId                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCameraComponent*                 InCameraComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMyTownLibrary::RegisterSlotCamera(class UObject* WorldContextObject, int32 MapSlotId, class UCameraComponent* InCameraComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "RegisterSlotCamera");

	Params::MyTownLibrary_RegisterSlotCamera Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MapSlotId = MapSlotId;
	Parms.InCameraComponent = InCameraComponent;

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

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

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownLibrary.ReinitializeManagerData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMyTownLibrary::ReinitializeManagerData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "ReinitializeManagerData");

	Params::MyTownLibrary_ReinitializeManagerData Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownLibrary.SetInputEnabled
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UMyTownLibrary::SetInputEnabled(class UObject* WorldContextObject, bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("MyTownLibrary", "SetInputEnabled");

	Params::MyTownLibrary_SetInputEnabled Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bEnable = bEnable;

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

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

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortClientNotification.NotificationIsFinished
// (BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortClientNotification::NotificationIsFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientNotification", "NotificationIsFinished");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortClientNotification.OnNotificationStart
// (BlueprintCosmetic, Native, Event, Protected, BlueprintEvent)

void AFortClientNotification::OnNotificationStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientNotification", "OnNotificationStart");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortClientNotification.PlayFeedbackLine
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// class USoundBase*                       Audio                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OverrideDelay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortClientNotification::PlayFeedbackLine(class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo, class USoundBase* Audio, float OverrideDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientNotification", "PlayFeedbackLine");

	Params::FortClientNotification_PlayFeedbackLine Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Audio = Audio;
	Parms.OverrideDelay = OverrideDelay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortClientNotification.SetDisplayText
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      DisplayText                                            (Parm, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortClientNotification::SetDisplayText(const class FText& DisplayText, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientNotification", "SetDisplayText");

	Params::FortClientNotification_SetDisplayText Parms{};

	Parms.DisplayText = std::move(DisplayText);
	Parms.bForce = bForce;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortClientNotification.SetupDelayedStop
// (Final, Native, Protected)
// Parameters:
// float                                   KillTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortClientNotification::SetupDelayedStop(float KillTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientNotification", "SetupDelayedStop");

	Params::FortClientNotification_SetupDelayedStop Parms{};

	Parms.KillTime = KillTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.CancelMatchmaking
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::CancelMatchmaking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "CancelMatchmaking");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.DisconnectFromLobby
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::DisconnectFromLobby()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "DisconnectFromLobby");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.EnterOutpost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMatchmakingContext::EnterOutpost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "EnterOutpost");

	Params::FortMatchmakingContext_EnterOutpost Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMatchmakingContext.GetLobbyWaitForPlayersTimeRemaining
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortMatchmakingContext::GetLobbyWaitForPlayersTimeRemaining()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "GetLobbyWaitForPlayersTimeRemaining");

	Params::FortMatchmakingContext_GetLobbyWaitForPlayersTimeRemaining Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMatchmakingContext.IsConnectedToGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMatchmakingContext::IsConnectedToGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "IsConnectedToGame");

	Params::FortMatchmakingContext_IsConnectedToGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMatchmakingContext.IsWorldRecordLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMatchmakingContext::IsWorldRecordLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "IsWorldRecordLoaded");

	Params::FortMatchmakingContext_IsWorldRecordLoaded Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMatchmakingContext.JoinFromLobby
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::JoinFromLobby()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "JoinFromLobby");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.ReadyUp
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::ReadyUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "ReadyUp");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.StartCriticalMission
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   MinMissionPower                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxMissionPower                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMatchmakingContext::StartCriticalMission(int32 MinMissionPower, int32 MaxMissionPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "StartCriticalMission");

	Params::FortMatchmakingContext_StartCriticalMission Parms{};

	Parms.MinMissionPower = MinMissionPower;
	Parms.MaxMissionPower = MaxMissionPower;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.StartMatchmaking
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::StartMatchmaking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "StartMatchmaking");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.StartOnboardingMission
// (Final, Native, Public, BlueprintCallable)

void UFortMatchmakingContext::StartOnboardingMission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "StartOnboardingMission");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMatchmakingContext.IsInLobby
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMatchmakingContext::IsInLobby() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "IsInLobby");

	Params::FortMatchmakingContext_IsInLobby Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMatchmakingContext.IsOutpostPermitted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMatchmakingContext::IsOutpostPermitted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMatchmakingContext", "IsOutpostPermitted");

	Params::FortMatchmakingContext_IsOutpostPermitted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.ActivateSlot
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AcivateDelay                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ActivateSlot(EFortQuickBars InQuickBar, int32 Slot, float AcivateDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ActivateSlot");

	Params::FortPlayerController_ActivateSlot Parms{};

	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;
	Parms.AcivateDelay = AcivateDelay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.Cheat
// (Final, Exec, Native, Protected)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::Cheat(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "Cheat");

	Params::FortPlayerController_Cheat Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.CheatAll
// (Final, Exec, Native, Protected)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::CheatAll(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "CheatAll");

	Params::FortPlayerController_CheatAll Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientAddHeroSpecialization
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// class UFortHeroSpecialization*          NewSpecialization                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientAddHeroSpecialization(class UFortHeroSpecialization* NewSpecialization)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientAddHeroSpecialization");

	Params::FortPlayerController_ClientAddHeroSpecialization Parms{};

	Parms.NewSpecialization = NewSpecialization;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientCancelCrafting
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientCancelCrafting()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientCancelCrafting");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientClearDisabledActionMappings
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)

void AFortPlayerController::ClientClearDisabledActionMappings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientClearDisabledActionMappings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientDrawAttentionToUI
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientDrawAttentionToUI(const struct FGuid& MissionGuid, const struct FGameplayTagContainer& ObjectiveHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientDrawAttentionToUI");

	Params::FortPlayerController_ClientDrawAttentionToUI Parms{};

	Parms.MissionGuid = std::move(MissionGuid);
	Parms.ObjectiveHandle = std::move(ObjectiveHandle);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientExecuteInventoryItem
// (Net, NetReliable, Native, Event, Protected, HasDefaults, NetClient)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Delay                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientExecuteInventoryItem(const struct FGuid& ItemGuid, float Delay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientExecuteInventoryItem");

	Params::FortPlayerController_ClientExecuteInventoryItem Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Delay = Delay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientForceCancelBuildingTool
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientForceCancelBuildingTool()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientForceCancelBuildingTool");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientForceProfileQuery
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientForceProfileQuery()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientForceProfileQuery");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientGivePlayerLocalAccountItem
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class UFortAccountItemDefinition*       ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientGivePlayerLocalAccountItem(class UFortAccountItemDefinition* ItemDefinition, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientGivePlayerLocalAccountItem");

	Params::FortPlayerController_ClientGivePlayerLocalAccountItem Parms{};

	Parms.ItemDefinition = ItemDefinition;
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientHandleNotification
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// const class FString&                    TypeStr                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    PayloadStr                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientHandleNotification(const class FString& TypeStr, const class FString& PayloadStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientHandleNotification");

	Params::FortPlayerController_ClientHandleNotification Parms{};

	Parms.TypeStr = std::move(TypeStr);
	Parms.PayloadStr = std::move(PayloadStr);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientHideTutorialWidget
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientHideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientHideTutorialWidget");

	Params::FortPlayerController_ClientHideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientOnGenericPlayerInitialization
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientOnGenericPlayerInitialization()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientOnGenericPlayerInitialization");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientOpenChoiceUI
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// const struct FChoiceData&               ChoiceItems                                            (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientOpenChoiceUI(const struct FChoiceData& ChoiceItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientOpenChoiceUI");

	Params::FortPlayerController_ClientOpenChoiceUI Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientPingMinimap
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              PingColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientPingMinimap(const struct FVector& WorldLocation, const struct FLinearColor& PingColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientPingMinimap");

	Params::FortPlayerController_ClientPingMinimap Parms{};

	Parms.WorldLocation = std::move(WorldLocation);
	Parms.PingColor = std::move(PingColor);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientReadyCheckComplete
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// bool                                    bPassed                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientReadyCheckComplete(bool bPassed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientReadyCheckComplete");

	Params::FortPlayerController_ClientReadyCheckComplete Parms{};

	Parms.bPassed = bPassed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientRegisterWithParty
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientRegisterWithParty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientRegisterWithParty");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientRequestReadyCheck
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// const class FText&                      QueryText                                              (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FText&                      YesText                                                (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FText&                      NoText                                                 (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientRequestReadyCheck(const class FText& QueryText, const class FText& YesText, const class FText& NoText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientRequestReadyCheck");

	Params::FortPlayerController_ClientRequestReadyCheck Parms{};

	Parms.QueryText = std::move(QueryText);
	Parms.YesText = std::move(YesText);
	Parms.NoText = std::move(NoText);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSendClientNotification
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const struct FFortClientNotificationData&NewClientNotification                                  (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSendClientNotification(const struct FFortClientNotificationData& NewClientNotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSendClientNotification");

	Params::FortPlayerController_ClientSendClientNotification Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSendEventNotification
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const class FName                       NotificationName                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UObject*                    NotificationParameter                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRemoveIfActive                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSendEventNotification(const class FName NotificationName, const class UObject* NotificationParameter, bool bRemoveIfActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSendEventNotification");

	Params::FortPlayerController_ClientSendEventNotification Parms{};

	Parms.NotificationName = NotificationName;
	Parms.NotificationParameter = NotificationParameter;
	Parms.bRemoveIfActive = bRemoveIfActive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSendTutorialNotification
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const struct FFortTutorialNotificationData&NewTutorialNotification                                (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSendTutorialNotification(const struct FFortTutorialNotificationData& NewTutorialNotification)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSendTutorialNotification");

	Params::FortPlayerController_ClientSendTutorialNotification Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSetActionMappingEnabled
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class FName                             ActionName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSetActionMappingEnabled(class FName ActionName, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSetActionMappingEnabled");

	Params::FortPlayerController_ClientSetActionMappingEnabled Parms{};

	Parms.ActionName = ActionName;
	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSetInviteFlags
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const struct FJoinabilitySettings&      Settings                                               (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSetInviteFlags(const struct FJoinabilitySettings& Settings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSetInviteFlags");

	Params::FortPlayerController_ClientSetInviteFlags Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientSetSpectatorCamera
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// const struct FVector&                   CameraLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  CameraRotation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientSetSpectatorCamera(const struct FVector& CameraLocation, const struct FRotator& CameraRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientSetSpectatorCamera");

	Params::FortPlayerController_ClientSetSpectatorCamera Parms{};

	Parms.CameraLocation = std::move(CameraLocation);
	Parms.CameraRotation = std::move(CameraRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientStayWithParty
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// bool                                    bStayWithParty                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientStayWithParty(bool bStayWithParty)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientStayWithParty");

	Params::FortPlayerController_ClientStayWithParty Parms{};

	Parms.bStayWithParty = bStayWithParty;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientStopUIFeedbackEvent
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientStopUIFeedbackEvent(class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientStopUIFeedbackEvent");

	Params::FortPlayerController_ClientStopUIFeedbackEvent Parms{};

	Parms.EventName = EventName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientTriggerUIFeedbackEvent
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientTriggerUIFeedbackEvent(class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientTriggerUIFeedbackEvent");

	Params::FortPlayerController_ClientTriggerUIFeedbackEvent Parms{};

	Parms.EventName = EventName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientUnableToPlaceGenerator
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerController::ClientUnableToPlaceGenerator()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientUnableToPlaceGenerator");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientUnhideTutorialWidget
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientUnhideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientUnhideTutorialWidget");

	Params::FortPlayerController_ClientUnhideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientUpdateRichPresence
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// ERichPresenceStateChange                RichPresenceChange                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bImportant                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientUpdateRichPresence(ERichPresenceStateChange RichPresenceChange, bool bImportant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientUpdateRichPresence");

	Params::FortPlayerController_ClientUpdateRichPresence Parms{};

	Parms.RichPresenceChange = RichPresenceChange;
	Parms.bImportant = bImportant;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ClientZoneSay
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// const class FString&                    PlayerName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ClientZoneSay(const class FString& PlayerName, const class FString& Message)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ClientZoneSay");

	Params::FortPlayerController_ClientZoneSay Parms{};

	Parms.PlayerName = std::move(PlayerName);
	Parms.Message = std::move(Message);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.Emote
// (Exec, Native, Public)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::Emote(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "Emote");

	Params::FortPlayerController_Emote Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ForceUpdateQuickbar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortQuickBars                          QuickbarToRefresh                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ForceUpdateQuickbar(EFortQuickBars QuickbarToRefresh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ForceUpdateQuickbar");

	Params::FortPlayerController_ForceUpdateQuickbar Parms{};

	Parms.QuickbarToRefresh = QuickbarToRefresh;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.GetAIDirectorDataManager
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIDirectorDataManager*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIDirectorDataManager* AFortPlayerController::GetAIDirectorDataManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GetAIDirectorDataManager");

	Params::FortPlayerController_GetAIDirectorDataManager Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.GivePlayerAmmo
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   AmmoCount                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::GivePlayerAmmo(int32 AmmoCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GivePlayerAmmo");

	Params::FortPlayerController_GivePlayerAmmo Parms{};

	Parms.AmmoCount = AmmoCount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.HandleWorldInventoryLocalUpdate
// (Final, Native, Public)

void AFortPlayerController::HandleWorldInventoryLocalUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "HandleWorldInventoryLocalUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.LocalOnBlueprintEdit
// (Final, Native, Protected)
// Parameters:
// class ABuildingSMActor*                 EditedActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::LocalOnBlueprintEdit(class ABuildingSMActor* EditedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "LocalOnBlueprintEdit");

	Params::FortPlayerController_LocalOnBlueprintEdit Parms{};

	Parms.EditedActor = EditedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_bHasServerFinishedLoading
// (Final, Native, Protected)

void AFortPlayerController::OnRep_bHasServerFinishedLoading()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_bHasServerFinishedLoading");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_CheatMovement
// (Final, Native, Protected)

void AFortPlayerController::OnRep_CheatMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_CheatMovement");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_CombatManager
// (Final, Native, Protected)

void AFortPlayerController::OnRep_CombatManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_CombatManager");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_IntensityGraphInfo
// (Final, Native, Public)

void AFortPlayerController::OnRep_IntensityGraphInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_IntensityGraphInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_LatestRewardReport
// (Final, Native, Protected)

void AFortPlayerController::OnRep_LatestRewardReport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_LatestRewardReport");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_PIDContributionsGraphInfo
// (Final, Native, Public)

void AFortPlayerController::OnRep_PIDContributionsGraphInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_PIDContributionsGraphInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_PIDValuesGraphInfo
// (Final, Native, Public)

void AFortPlayerController::OnRep_PIDValuesGraphInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_PIDValuesGraphInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_PinnedSchematics
// (Native, Protected)

void AFortPlayerController::OnRep_PinnedSchematics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_PinnedSchematics");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_QuickBar
// (Native, Protected)

void AFortPlayerController::OnRep_QuickBar()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_QuickBar");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OnRep_UpdatedObjectiveStats
// (Final, Native, Protected)

void AFortPlayerController::OnRep_UpdatedObjectiveStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OnRep_UpdatedObjectiveStats");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.OpenChoiceUI
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FChoiceData&               ChoiceData                                             (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::OpenChoiceUI(const struct FChoiceData& ChoiceData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "OpenChoiceUI");

	Params::FortPlayerController_OpenChoiceUI Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.PlaySpatialSound
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class USoundBase*                       Sound                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::PlaySpatialSound(class USoundBase* Sound, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "PlaySpatialSound");

	Params::FortPlayerController_PlaySpatialSound Parms{};

	Parms.Sound = Sound;
	Parms.Location = std::move(Location);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.PrintDebugInfo
// (Exec, Native, Protected)

void AFortPlayerController::PrintDebugInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "PrintDebugInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.RemoveItemFromQuickBars
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortItemDefinition*              ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::RemoveItemFromQuickBars(class UFortItemDefinition* ItemDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "RemoveItemFromQuickBars");

	Params::FortPlayerController_RemoveItemFromQuickBars Parms{};

	Parms.ItemDefinition = ItemDefinition;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ResetInputRotationScale
// (Final, Native, Public, BlueprintCallable)

void AFortPlayerController::ResetInputRotationScale()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ResetInputRotationScale");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.Say
// (Exec, Native, Public)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::Say(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "Say");

	Params::FortPlayerController_Say Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SayTeam
// (Exec, Native, Public)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SayTeam(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SayTeam");

	Params::FortPlayerController_SayTeam Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SendMessage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SendMessage(const class FString& Message, class FName Type, class AActor* Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SendMessage");

	Params::FortPlayerController_SendMessage Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SendTextNotification
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FText&                      NotificationText                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   DisplayTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SendTextNotification(const class FText& NotificationText, float DisplayTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SendTextNotification");

	Params::FortPlayerController_SendTextNotification Parms{};

	Parms.NotificationText = std::move(NotificationText);
	Parms.DisplayTime = DisplayTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerAttemptInteract
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class AActor*                           ReceivingActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              InteractComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETInteractionType                       InteractType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerAttemptInteract(class AActor* ReceivingActor, class UPrimitiveComponent* InteractComponent, ETInteractionType InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerAttemptInteract");

	Params::FortPlayerController_ServerAttemptInteract Parms{};

	Parms.ReceivingActor = ReceivingActor;
	Parms.InteractComponent = InteractComponent;
	Parms.InteractType = InteractType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerAttemptPinSchematic
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    ItemId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSave                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerAttemptPinSchematic(const class FString& ItemId, bool bSave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerAttemptPinSchematic");

	Params::FortPlayerController_ServerAttemptPinSchematic Parms{};

	Parms.ItemId = std::move(ItemId);
	Parms.bSave = bSave;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerAttemptUnpinSchematic
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    ItemId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSave                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerAttemptUnpinSchematic(const class FString& ItemId, bool bSave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerAttemptUnpinSchematic");

	Params::FortPlayerController_ServerAttemptUnpinSchematic Parms{};

	Parms.ItemId = std::move(ItemId);
	Parms.bSave = bSave;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerBanPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerToBan                                            (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerBanPlayer(const struct FUniqueNetIdRepl& PlayerToBan)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerBanPlayer");

	Params::FortPlayerController_ServerBanPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerBeginEditingBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingSMActor*                 BuildingActorToEdit                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerBeginEditingBuildingActor(class ABuildingSMActor* BuildingActorToEdit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerBeginEditingBuildingActor");

	Params::FortPlayerController_ServerBeginEditingBuildingActor Parms{};

	Parms.BuildingActorToEdit = BuildingActorToEdit;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerBroadcastUIFeedbackEvent
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerBroadcastUIFeedbackEvent(class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerBroadcastUIFeedbackEvent");

	Params::FortPlayerController_ServerBroadcastUIFeedbackEvent Parms{};

	Parms.EventName = EventName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCheat
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerCheat(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCheat");

	Params::FortPlayerController_ServerCheat Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCheatAll
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerCheatAll(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCheatAll");

	Params::FortPlayerController_ServerCheatAll Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerClientPawnLoaded
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// bool                                    bIsPawnLoaded                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerClientPawnLoaded(bool bIsPawnLoaded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerClientPawnLoaded");

	Params::FortPlayerController_ServerClientPawnLoaded Parms{};

	Parms.bIsPawnLoaded = bIsPawnLoaded;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCraftSchematic
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    ItemId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerCraftSchematic(const class FString& ItemId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCraftSchematic");

	Params::FortPlayerController_ServerCraftSchematic Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCreateAIDirectorDataManager
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerCreateAIDirectorDataManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCreateAIDirectorDataManager");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCreateBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FBuildingClassData&        BuildingClassData                                      (Parm, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize10&     BuildLoc                                               (Parm, NativeAccessSpecifierPublic)
// const struct FRotator&                  BuildRot                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bMirrored                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerCreateBuildingActor(const struct FBuildingClassData& BuildingClassData, const struct FVector_NetQuantize10& BuildLoc, const struct FRotator& BuildRot, bool bMirrored)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCreateBuildingActor");

	Params::FortPlayerController_ServerCreateBuildingActor Parms{};

	Parms.BuildingClassData = std::move(BuildingClassData);
	Parms.BuildLoc = std::move(BuildLoc);
	Parms.BuildRot = std::move(BuildRot);
	Parms.bMirrored = bMirrored;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerCreateCombatManager
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerCreateCombatManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerCreateCombatManager");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerDisassembleInventoryItem
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerDisassembleInventoryItem(const struct FGuid& ItemGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerDisassembleInventoryItem");

	Params::FortPlayerController_ServerDisassembleInventoryItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerDropCarriedObject
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerDropCarriedObject()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerDropCarriedObject");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerEditBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingSMActor*                 BuildingActorToEdit                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class ABuildingSMActor>     NewBuildingClass                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RotationIterations                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMirrored                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerEditBuildingActor(class ABuildingSMActor* BuildingActorToEdit, TSubclassOf<class ABuildingSMActor> NewBuildingClass, int32 RotationIterations, bool bMirrored)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerEditBuildingActor");

	Params::FortPlayerController_ServerEditBuildingActor Parms{};

	Parms.BuildingActorToEdit = BuildingActorToEdit;
	Parms.NewBuildingClass = NewBuildingClass;
	Parms.RotationIterations = RotationIterations;
	Parms.bMirrored = bMirrored;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerEmote
// (Net, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerEmote(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerEmote");

	Params::FortPlayerController_ServerEmote Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerEndEditingBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingSMActor*                 BuildingActorToStopEditing                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerEndEditingBuildingActor(class ABuildingSMActor* BuildingActorToStopEditing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerEndEditingBuildingActor");

	Params::FortPlayerController_ServerEndEditingBuildingActor Parms{};

	Parms.BuildingActorToStopEditing = BuildingActorToStopEditing;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerExecuteInventoryItem
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerExecuteInventoryItem(const struct FGuid& ItemGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerExecuteInventoryItem");

	Params::FortPlayerController_ServerExecuteInventoryItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerForceProfileQuery
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerForceProfileQuery()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerForceProfileQuery");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerGiftInventoryItemToOtherPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FUniqueNetIdRepl&          PlayerID                                               (Parm, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerGiftInventoryItemToOtherPlayer(const struct FGuid& ItemGuid, const struct FUniqueNetIdRepl& PlayerID, int32 Quantity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerGiftInventoryItemToOtherPlayer");

	Params::FortPlayerController_ServerGiftInventoryItemToOtherPlayer Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.PlayerID = std::move(PlayerID);
	Parms.Quantity = Quantity;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerGrantAdminPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerToAdmin                                          (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerGrantAdminPlayer(const struct FUniqueNetIdRepl& PlayerToAdmin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerGrantAdminPlayer");

	Params::FortPlayerController_ServerGrantAdminPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerHandleMissionEvent_ToggledCursorMode
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class AFortPlayerController*            PlayerThatToggledCursorMode                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOpened                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerHandleMissionEvent_ToggledCursorMode(class AFortPlayerController* PlayerThatToggledCursorMode, bool bOpened)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerHandleMissionEvent_ToggledCursorMode");

	Params::FortPlayerController_ServerHandleMissionEvent_ToggledCursorMode Parms{};

	Parms.PlayerThatToggledCursorMode = PlayerThatToggledCursorMode;
	Parms.bOpened = bOpened;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerHandleMissionEvent_ToggledEditMode
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class AFortPlayerController*            PlayerThatToggledEditMode                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOpened                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerHandleMissionEvent_ToggledEditMode(class AFortPlayerController* PlayerThatToggledEditMode, bool bOpened)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerHandleMissionEvent_ToggledEditMode");

	Params::FortPlayerController_ServerHandleMissionEvent_ToggledEditMode Parms{};

	Parms.PlayerThatToggledEditMode = PlayerThatToggledEditMode;
	Parms.bOpened = bOpened;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerHandleMissionEvent_ToggledOptionsMenu
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class AFortPlayerController*            PlayerThatToggledOptionsMenu                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOpened                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerHandleMissionEvent_ToggledOptionsMenu(class AFortPlayerController* PlayerThatToggledOptionsMenu, bool bOpened)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerHandleMissionEvent_ToggledOptionsMenu");

	Params::FortPlayerController_ServerHandleMissionEvent_ToggledOptionsMenu Parms{};

	Parms.PlayerThatToggledOptionsMenu = PlayerThatToggledOptionsMenu;
	Parms.bOpened = bOpened;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerItemWillBeDestroyed
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     DestroyedItemGuid                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerItemWillBeDestroyed(const struct FGuid& DestroyedItemGuid, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerItemWillBeDestroyed");

	Params::FortPlayerController_ServerItemWillBeDestroyed Parms{};

	Parms.DestroyedItemGuid = std::move(DestroyedItemGuid);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerKickPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerToKick                                           (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FText&                      Reason                                                 (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerKickPlayer(const struct FUniqueNetIdRepl& PlayerToKick, const class FText& Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerKickPlayer");

	Params::FortPlayerController_ServerKickPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerKillAllAIPawnsAroundPlayer
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerKillAllAIPawnsAroundPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerKillAllAIPawnsAroundPlayer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerModDurability
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DurabilityMod                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceSet                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerModDurability(const struct FGuid& ItemGuid, float DurabilityMod, bool bForceSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerModDurability");

	Params::FortPlayerController_ServerModDurability Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.DurabilityMod = DurabilityMod;
	Parms.bForceSet = bForceSet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerModifyStat
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class FName                             StatName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EStatMod                                ModType                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceStatSave                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerModifyStat(class FName StatName, int32 Amount, EStatMod ModType, bool bForceStatSave)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerModifyStat");

	Params::FortPlayerController_ServerModifyStat Parms{};

	Parms.StatName = StatName;
	Parms.Amount = Amount;
	Parms.ModType = ModType;
	Parms.bForceStatSave = bForceStatSave;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerNotificationIsFinished
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     NotificationID                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerNotificationIsFinished(const struct FGuid& NotificationID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerNotificationIsFinished");

	Params::FortPlayerController_ServerNotificationIsFinished Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerOnBannerUpdate
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerOnBannerUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerOnBannerUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerPingMinimap
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              PingColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerPingMinimap(const struct FVector& WorldLocation, const struct FLinearColor& PingColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerPingMinimap");

	Params::FortPlayerController_ServerPingMinimap Parms{};

	Parms.WorldLocation = std::move(WorldLocation);
	Parms.PingColor = std::move(PingColor);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReadyToStartMatch
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerReadyToStartMatch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReadyToStartMatch");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReconcileGiftsFromPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    PlayerName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAccept                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerReconcileGiftsFromPlayer(const class FString& PlayerName, bool bAccept)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReconcileGiftsFromPlayer");

	Params::FortPlayerController_ServerReconcileGiftsFromPlayer Parms{};

	Parms.PlayerName = std::move(PlayerName);
	Parms.bAccept = bAccept;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReleaseInventoryItemKey
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// EFortQuickBars                          InQuickBar                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerReleaseInventoryItemKey(EFortQuickBars InQuickBar, int32 Slot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReleaseInventoryItemKey");

	Params::FortPlayerController_ServerReleaseInventoryItemKey Parms{};

	Parms.InQuickBar = InQuickBar;
	Parms.Slot = Slot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerRemoveAdminPlayer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerToAdmin                                          (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerRemoveAdminPlayer(const struct FUniqueNetIdRepl& PlayerToAdmin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerRemoveAdminPlayer");

	Params::FortPlayerController_ServerRemoveAdminPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerRemoveInventoryItem
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceRemoveFromQuickBars                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerRemoveInventoryItem(const struct FGuid& ItemGuid, int32 Count, bool bForceRemoveFromQuickBars)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerRemoveInventoryItem");

	Params::FortPlayerController_ServerRemoveInventoryItem Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Count = Count;
	Parms.bForceRemoveFromQuickBars = bForceRemoveFromQuickBars;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerRemoveInventoryStateValue
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EFortItemEntryState                     StateValueType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerRemoveInventoryStateValue(const struct FGuid& ItemGuid, EFortItemEntryState StateValueType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerRemoveInventoryStateValue");

	Params::FortPlayerController_ServerRemoveInventoryStateValue Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.StateValueType = StateValueType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerRepairBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingSMActor*                 BuildingActorToRepair                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerRepairBuildingActor(class ABuildingSMActor* BuildingActorToRepair)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerRepairBuildingActor");

	Params::FortPlayerController_ServerRepairBuildingActor Parms{};

	Parms.BuildingActorToRepair = BuildingActorToRepair;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReplyToReadyCheck
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                                    bReady                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerReplyToReadyCheck(bool bReady)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReplyToReadyCheck");

	Params::FortPlayerController_ServerReplyToReadyCheck Parms{};

	Parms.bReady = bReady;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerRequestGameplayAction
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortRequestedGameplayAction            RequestedAction                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerRequestGameplayAction(EFortRequestedGameplayAction RequestedAction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerRequestGameplayAction");

	Params::FortPlayerController_ServerRequestGameplayAction Parms{};

	Parms.RequestedAction = RequestedAction;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReturnToLobby
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerReturnToLobby()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReturnToLobby");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerReturnToMainMenu
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerReturnToMainMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerReturnToMainMenu");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSaveLoadoutData
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    NewHeroID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSelectedClassAbilityKits& ForceSelectedAbilities                                 (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSaveLoadoutData(const class FString& NewHeroID, const struct FSelectedClassAbilityKits& ForceSelectedAbilities)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSaveLoadoutData");

	Params::FortPlayerController_ServerSaveLoadoutData Parms{};

	Parms.NewHeroID = std::move(NewHeroID);
	Parms.ForceSelectedAbilities = std::move(ForceSelectedAbilities);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSay
// (Net, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSay(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSay");

	Params::FortPlayerController_ServerSay Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSayTeam
// (Net, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSayTeam(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSayTeam");

	Params::FortPlayerController_ServerSayTeam Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetAnalyticsIds
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    SessionId                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    UserId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetAnalyticsIds(const class FString& SessionId, const class FString& UserId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetAnalyticsIds");

	Params::FortPlayerController_ServerSetAnalyticsIds Parms{};

	Parms.SessionId = std::move(SessionId);
	Parms.UserId = std::move(UserId);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetAutoEquipBetterItems
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                                    bAutoEquip                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetAutoEquipBetterItems(bool bAutoEquip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetAutoEquipBetterItems");

	Params::FortPlayerController_ServerSetAutoEquipBetterItems Parms{};

	Parms.bAutoEquip = bAutoEquip;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetClientHasFinishedLoading
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// bool                                    bInHasFinishedLoading                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetClientHasFinishedLoading(bool bInHasFinishedLoading)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetClientHasFinishedLoading");

	Params::FortPlayerController_ServerSetClientHasFinishedLoading Parms{};

	Parms.bInHasFinishedLoading = bInHasFinishedLoading;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetHero
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    NewHeroID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetHero(const class FString& NewHeroID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetHero");

	Params::FortPlayerController_ServerSetHero Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetInventoryStateValue
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FFortItemEntryStateValue&  StateValue                                             (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetInventoryStateValue(const struct FGuid& ItemGuid, const struct FFortItemEntryStateValue& StateValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetInventoryStateValue");

	Params::FortPlayerController_ServerSetInventoryStateValue Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.StateValue = std::move(StateValue);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetInvincibleDueToUI
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                                    bInvincible                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetInvincibleDueToUI(bool bInvincible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetInvincibleDueToUI");

	Params::FortPlayerController_ServerSetInvincibleDueToUI Parms{};

	Parms.bInvincible = bInvincible;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetMarkText
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class AFortMarkActor*                   MarkActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MarkText                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetMarkText(class AFortMarkActor* MarkActor, const class FString& MarkText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetMarkText");

	Params::FortPlayerController_ServerSetMarkText Parms{};

	Parms.MarkActor = MarkActor;
	Parms.MarkText = std::move(MarkText);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetPartyOwner
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          PartyOwnerUniqueId                                     (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetPartyOwner(const struct FUniqueNetIdRepl& PartyOwnerUniqueId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetPartyOwner");

	Params::FortPlayerController_ServerSetPartyOwner Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetPlayerStatus
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// uint32                                  PlayerStatus                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetPlayerStatus(uint32 PlayerStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetPlayerStatus");

	Params::FortPlayerController_ServerSetPlayerStatus Parms{};

	Parms.PlayerStatus = PlayerStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetReadyToContinue
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                                    bReady                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EFortGameplayState                      RequestedState                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTryStartTimer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetReadyToContinue(bool bReady, EFortGameplayState RequestedState, bool bTryStartTimer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetReadyToContinue");

	Params::FortPlayerController_ServerSetReadyToContinue Parms{};

	Parms.bReady = bReady;
	Parms.RequestedState = RequestedState;
	Parms.bTryStartTimer = bTryStartTimer;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetTimeOfDay
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// float                                   TimeOfDay                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetTimeOfDay(float TimeOfDay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetTimeOfDay");

	Params::FortPlayerController_ServerSetTimeOfDay Parms{};

	Parms.TimeOfDay = TimeOfDay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSetupWeakSpotsOnBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingSMActor*                 BuildingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortCrackEffectData&      CrackData                                              (Parm, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSetupWeakSpotsOnBuildingActor(class ABuildingSMActor* BuildingActor, const struct FFortCrackEffectData& CrackData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSetupWeakSpotsOnBuildingActor");

	Params::FortPlayerController_ServerSetupWeakSpotsOnBuildingActor Parms{};

	Parms.BuildingActor = BuildingActor;
	Parms.CrackData = std::move(CrackData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSpawnInventoryDrop
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSpawnInventoryDrop(const struct FGuid& ItemGuid, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSpawnInventoryDrop");

	Params::FortPlayerController_ServerSpawnInventoryDrop Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSpawnMark
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// class AActor*                           ActorToAttachTo                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AttachOffset                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSpawnMark(class AActor* ActorToAttachTo, const struct FVector& AttachOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSpawnMark");

	Params::FortPlayerController_ServerSpawnMark Parms{};

	Parms.ActorToAttachTo = ActorToAttachTo;
	Parms.AttachOffset = std::move(AttachOffset);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSpotActor
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class AActor*                           NewlySpottedActor                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerSpotActor(class AActor* NewlySpottedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSpotActor");

	Params::FortPlayerController_ServerSpotActor Parms{};

	Parms.NewlySpottedActor = NewlySpottedActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerStartIntensityGraphing
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerStartIntensityGraphing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerStartIntensityGraphing");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerStartPIDContributionsGraphing
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerStartPIDContributionsGraphing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerStartPIDContributionsGraphing");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerStartPIDValueGraphing
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerStartPIDValueGraphing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerStartPIDValueGraphing");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerSuicide
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerController::ServerSuicide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerSuicide");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerTeleportToReticle
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FVector&                   TeleportLocation                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerTeleportToReticle(const struct FVector& TeleportLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerTeleportToReticle");

	Params::FortPlayerController_ServerTeleportToReticle Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerTouchActiveTime
// (Net, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerController::ServerTouchActiveTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerTouchActiveTime");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerTriggerCombatEvent
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortCombatEvents                       TriggeredEvent                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HeatMultiplier                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerTriggerCombatEvent(EFortCombatEvents TriggeredEvent, float HeatMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerTriggerCombatEvent");

	Params::FortPlayerController_ServerTriggerCombatEvent Parms{};

	Parms.TriggeredEvent = TriggeredEvent;
	Parms.HeatMultiplier = HeatMultiplier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerUIChoiceCompleted
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// int32                                   ChosenItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MenuIdentifier                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerUIChoiceCompleted(int32 ChosenItem, int32 MenuIdentifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerUIChoiceCompleted");

	Params::FortPlayerController_ServerUIChoiceCompleted Parms{};

	Parms.ChosenItem = ChosenItem;
	Parms.MenuIdentifier = MenuIdentifier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ServerUpgradeBuildingActor
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ABuildingActor*                   BuildingActorToUpgrade                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewUpgradeLevel                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::ServerUpgradeBuildingActor(class ABuildingActor* BuildingActorToUpgrade, int32 NewUpgradeLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ServerUpgradeBuildingActor");

	Params::FortPlayerController_ServerUpgradeBuildingActor Parms{};

	Parms.BuildingActorToUpgrade = BuildingActorToUpgrade;
	Parms.NewUpgradeLevel = NewUpgradeLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SetCinematicOverrideClass
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortCinematicCamera> OverrideCameraClass                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SetCinematicOverrideClass(TSubclassOf<class UFortCinematicCamera> OverrideCameraClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SetCinematicOverrideClass");

	Params::FortPlayerController_SetCinematicOverrideClass Parms{};

	Parms.OverrideCameraClass = OverrideCameraClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SetInputPitchScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InInputPitchScale                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SetInputPitchScale(float InInputPitchScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SetInputPitchScale");

	Params::FortPlayerController_SetInputPitchScale Parms{};

	Parms.InInputPitchScale = InInputPitchScale;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SetInputYawScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InInputYawScale                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerController::SetInputYawScale(float InInputYawScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SetInputYawScale");

	Params::FortPlayerController_SetInputYawScale Parms{};

	Parms.InInputYawScale = InInputYawScale;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SetShowHUD
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewShowHUD                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::SetShowHUD(bool bNewShowHUD)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SetShowHUD");

	Params::FortPlayerController_SetShowHUD Parms{};

	Parms.bNewShowHUD = bNewShowHUD;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SpawnCameraLensEffectDirectional
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSubclassOf<class AFortEmitterCameraLensEffectDirectional>LensEffectEmitterClass                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        DamageDealer                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AFortEmitterCameraLensEffectDirectional*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortEmitterCameraLensEffectDirectional* AFortPlayerController::SpawnCameraLensEffectDirectional(TSubclassOf<class AFortEmitterCameraLensEffectDirectional> LensEffectEmitterClass, class AFortPawn* DamageDealer, const struct FHitResult& HitInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SpawnCameraLensEffectDirectional");

	Params::FortPlayerController_SpawnCameraLensEffectDirectional Parms{};

	Parms.LensEffectEmitterClass = LensEffectEmitterClass;
	Parms.DamageDealer = DamageDealer;
	Parms.HitInfo = std::move(HitInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.StartReadyCheck
// (Final, BlueprintAuthorityOnly, Exec, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      QueryText                                              (Parm, NativeAccessSpecifierPublic)
// const class FText&                      YesText                                                (Parm, NativeAccessSpecifierPublic)
// const class FText&                      NoText                                                 (Parm, NativeAccessSpecifierPublic)
// float                                   PercentageToPass                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerController::StartReadyCheck(const class FText& QueryText, const class FText& YesText, const class FText& NoText, float PercentageToPass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "StartReadyCheck");

	Params::FortPlayerController_StartReadyCheck Parms{};

	Parms.QueryText = std::move(QueryText);
	Parms.YesText = std::move(YesText);
	Parms.NoText = std::move(NoText);
	Parms.PercentageToPass = PercentageToPass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.Suicide
// (Exec, Native, Public)

void AFortPlayerController::Suicide()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "Suicide");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.SuppressEventNotifications
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSuppress                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerController::SuppressEventNotifications(bool bSuppress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "SuppressEventNotifications");

	Params::FortPlayerController_SuppressEventNotifications Parms{};

	Parms.bSuppress = bSuppress;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ToggleFullScreenMap
// (Final, Exec, Native, Public)

void AFortPlayerController::ToggleFullScreenMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ToggleFullScreenMap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ToggleInventory
// (Exec, Native, Public)

void AFortPlayerController::ToggleInventory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ToggleInventory");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ToggleMirrorBuildPreview
// (Native, Protected)

void AFortPlayerController::ToggleMirrorBuildPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ToggleMirrorBuildPreview");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.ToggleStats
// (Exec, Native, Public)

void AFortPlayerController::ToggleStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "ToggleStats");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.DumpHomebaseRatingInfo
// (Final, Exec, Native, Public, Const)

void AFortPlayerController::DumpHomebaseRatingInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "DumpHomebaseRatingInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerController.GetAccountLevel
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortPlayerController::GetAccountLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GetAccountLevel");

	Params::FortPlayerController_GetAccountLevel Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.GetAccountLevelProgression
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerController::GetAccountLevelProgression() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GetAccountLevelProgression");

	Params::FortPlayerController_GetAccountLevelProgression Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.GetActorUnderReticle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortPlayerController::GetActorUnderReticle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GetActorUnderReticle");

	Params::FortPlayerController_GetActorUnderReticle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.GetQuestManager
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortQuestManager*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestManager* AFortPlayerController::GetQuestManager() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "GetQuestManager");

	Params::FortPlayerController_GetQuestManager Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.IsClientBot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerController::IsClientBot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "IsClientBot");

	Params::FortPlayerController_IsClientBot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.IsRequirementsMet
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortRequirementsInfo&     InRequirements                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerController::IsRequirementsMet(const struct FFortRequirementsInfo& InRequirements) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "IsRequirementsMet");

	Params::FortPlayerController_IsRequirementsMet Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerController.IsUsingFirstPersonCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerController::IsUsingFirstPersonCamera() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerController", "IsUsingFirstPersonCamera");

	Params::FortPlayerController_IsUsingFirstPersonCamera Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltipInterface.GetTooltip
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UFortTooltip>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UFortTooltip> IFortTooltipInterface::GetTooltip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltipInterface", "GetTooltip");

	Params::FortTooltipInterface_GetTooltip Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltipContext.SpawnTooltipContext
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UFortTooltipContext*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortTooltipContext* UFortTooltipContext::SpawnTooltipContext()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortTooltipContext", "SpawnTooltipContext");

	Params::FortTooltipContext_SpawnTooltipContext Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinition.CreateTemporaryItemInstanceBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItem*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItem* UFortItemDefinition::CreateTemporaryItemInstanceBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "CreateTemporaryItemInstanceBP");

	Params::FortItemDefinition_CreateTemporaryItemInstanceBP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinition.GetDescription
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FText>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FText> UFortItemDefinition::GetDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "GetDescription");

	Params::FortItemDefinition_GetDescription Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinition.GetDisplayName
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bBaseName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItemDefinition::GetDisplayName(bool bBaseName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "GetDisplayName");

	Params::FortItemDefinition_GetDisplayName Parms{};

	Parms.bBaseName = bBaseName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinition.GetIconBrush
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSlateBrush*                     IconBrush_0                                            (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemDefinition::GetIconBrush(struct FSlateBrush* IconBrush_0, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "GetIconBrush");

	Params::FortItemDefinition_GetIconBrush Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortItemDefinition.GetSingleLineDescription
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItemDefinition::GetSingleLineDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "GetSingleLineDescription");

	Params::FortItemDefinition_GetSingleLineDescription Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinition.GetTooltip
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UFortTooltip>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UFortTooltip> UFortItemDefinition::GetTooltip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinition", "GetTooltip");

	Params::FortItemDefinition_GetTooltip Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDamageNumbersActor.OnNewDamageNumber
// (Event, Protected, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FFortDamageNumberInfo&     NewDamageNumberInfo                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortDamageNumbersActor::OnNewDamageNumber(const struct FFortDamageNumberInfo& NewDamageNumberInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDamageNumbersActor", "OnNewDamageNumber");

	Params::FortDamageNumbersActor_OnNewDamageNumber Parms{};

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

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


// Function FortniteGame.FortTrait.GetAbilityKitSlots
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FFortAbilityKitSlot>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FFortAbilityKitSlot> UFortTrait::GetAbilityKitSlots()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrait", "GetAbilityKitSlots");

	Params::FortTrait_GetAbilityKitSlots Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCheatManager.AllowRespawn
// (Final, Exec, Native, Public)

void UFortCheatManager::AllowRespawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "AllowRespawn");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ApplyWeaponAlteration
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    AlterationName                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ApplyWeaponAlteration(const class FString& AlterationName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ApplyWeaponAlteration");

	Params::FortCheatManager_ApplyWeaponAlteration Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BackpackSetSize
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Size                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::BackpackSetSize(int32 Size)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BackpackSetSize");

	Params::FortCheatManager_BackpackSetSize Parms{};

	Parms.Size = Size;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.Badass
// (Final, Exec, Native, Public)

void UFortCheatManager::Badass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "Badass");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BanPlayer
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    PlayerName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::BanPlayer(const class FString& PlayerName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BanPlayer");

	Params::FortCheatManager_BanPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BeautyMode
// (Final, Exec, Native, Public)

void UFortCheatManager::BeautyMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BeautyMode");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BounceContainer
// (Final, Exec, Native, Public)

void UFortCheatManager::BounceContainer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BounceContainer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BuildFree
// (Final, Exec, Native, Public)

void UFortCheatManager::BuildFree()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BuildFree");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.BuildWith
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ResourceTypeAndOrLevel                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::BuildWith(const class FString& ResourceTypeAndOrLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "BuildWith");

	Params::FortCheatManager_BuildWith Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.CheatScript
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ScriptName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::CheatScript(const class FString& ScriptName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "CheatScript");

	Params::FortCheatManager_CheatScript Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearBannedPlayers
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearBannedPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearBannedPlayers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearEncounterSimulatedNumberOfPlayers
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearEncounterSimulatedNumberOfPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearEncounterSimulatedNumberOfPlayers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearEncounterSpawnPointsCap
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearEncounterSpawnPointsCap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearEncounterSpawnPointsCap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearEncounterSpawnPointsCurve
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearEncounterSpawnPointsCurve()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearEncounterSpawnPointsCurve");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearKeepSave
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearKeepSave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearKeepSave");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ClearRespawnTimer
// (Final, Exec, Native, Public)

void UFortCheatManager::ClearRespawnTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ClearRespawnTimer");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ConstructTileWorld
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   MaxTiles                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ConstructTileWorld(int32 MaxTiles, int32 X, int32 Y)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ConstructTileWorld");

	Params::FortCheatManager_ConstructTileWorld Parms{};

	Parms.MaxTiles = MaxTiles;
	Parms.X = X;
	Parms.Y = Y;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.CoverMap
// (Final, Exec, Native, Public)

void UFortCheatManager::CoverMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "CoverMap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.CycleCurrentEncounterToDebug
// (Exec, Native, Public)

void UFortCheatManager::CycleCurrentEncounterToDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "CycleCurrentEncounterToDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.CycleEncounterEQSQueryToDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::CycleEncounterEQSQueryToDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "CycleEncounterEQSQueryToDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.CycleTheaterDisplayed
// (Final, Exec, Native, Public)

void UFortCheatManager::CycleTheaterDisplayed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "CycleTheaterDisplayed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugAbilityTags
// (Exec, Native, Public)

void UFortCheatManager::DebugAbilityTags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugAbilityTags");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugAttribute
// (Exec, Native, Public, HasOutParams)
// Parameters:
// class FString*                          Attribute                                              (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::DebugAttribute(class FString* Attribute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugAttribute");

	Params::FortCheatManager_DebugAttribute Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortCheatManager.DebugAttributeClear
// (Exec, Native, Public)

void UFortCheatManager::DebugAttributeClear()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugAttributeClear");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugAttributeModifiers
// (Exec, Native, Public)

void UFortCheatManager::DebugAttributeModifiers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugAttributeModifiers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugBuildingDetection
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugBuildingDetection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugBuildingDetection");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugForceEnsure
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugForceEnsure()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugForceEnsure");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugHideLoadingScreen
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugHideLoadingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugHideLoadingScreen");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugHotSpots
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugHotSpots()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugHotSpots");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugKickPlayerDueToInactivity
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugKickPlayerDueToInactivity()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugKickPlayerDueToInactivity");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugLoadingScreen
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    MissionGen                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::DebugLoadingScreen(const class FString& MissionGen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugLoadingScreen");

	Params::FortCheatManager_DebugLoadingScreen Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugRifts
// (Final, Exec, Native, Public)

void UFortCheatManager::DebugRifts()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugRifts");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugStructuralSupport
// (Exec, Native, Public)

void UFortCheatManager::DebugStructuralSupport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugStructuralSupport");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugThisAI
// (Exec, Native, Public)

void UFortCheatManager::DebugThisAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugThisAI");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DebugUseDedicatedServer
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bUse                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::DebugUseDedicatedServer(bool bUse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DebugUseDedicatedServer");

	Params::FortCheatManager_DebugUseDedicatedServer Parms{};

	Parms.bUse = bUse;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DeleteWorld
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    WorldName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::DeleteWorld(const class FString& WorldName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DeleteWorld");

	Params::FortCheatManager_DeleteWorld Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DisableAI
// (Final, Exec, Native, Public)

void UFortCheatManager::DisableAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DisableAI");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DumpActiveGameplayEffects
// (Final, Exec, Native, Public)

void UFortCheatManager::DumpActiveGameplayEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DumpActiveGameplayEffects");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DumpActorsWithAssetTags
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    TagList                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::DumpActorsWithAssetTags(const class FString& TagList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DumpActorsWithAssetTags");

	Params::FortCheatManager_DumpActorsWithAssetTags Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DumpAllActorsWithAssetTags
// (Final, Exec, Native, Public)

void UFortCheatManager::DumpAllActorsWithAssetTags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DumpAllActorsWithAssetTags");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.DumpGameStats
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    FilterName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::DumpGameStats(const class FString& FilterName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "DumpGameStats");

	Params::FortCheatManager_DumpGameStats Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EnableAltKeybinds
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::EnableAltKeybinds(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EnableAltKeybinds");

	Params::FortCheatManager_EnableAltKeybinds Parms{};

	Parms.bEnable = bEnable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EnableNewCustomizationPanel
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::EnableNewCustomizationPanel(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EnableNewCustomizationPanel");

	Params::FortCheatManager_EnableNewCustomizationPanel Parms{};

	Parms.bEnable = bEnable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EncounterCurrentUtilities
// (Final, Exec, Native, Public)

void UFortCheatManager::EncounterCurrentUtilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EncounterCurrentUtilities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EncounterInitialUtilities
// (Final, Exec, Native, Public)

void UFortCheatManager::EncounterInitialUtilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EncounterInitialUtilities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EncounterSetDifficultyLevel
// (Final, Exec, Native, Public)
// Parameters:
// float                                   NewDifficulty                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::EncounterSetDifficultyLevel(float NewDifficulty)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EncounterSetDifficultyLevel");

	Params::FortCheatManager_EncounterSetDifficultyLevel Parms{};

	Parms.NewDifficulty = NewDifficulty;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EncounterSpawnProbabilities
// (Final, Exec, Native, Public)

void UFortCheatManager::EncounterSpawnProbabilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EncounterSpawnProbabilities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.EncounterTopUtilityPercentages
// (Final, Exec, Native, Public)

void UFortCheatManager::EncounterTopUtilityPercentages()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "EncounterTopUtilityPercentages");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ExecuteNewMissionGeneration
// (Final, Exec, Native, Public)
// Parameters:
// float                                   DifficultyLevel                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GeneratorName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ExecuteNewMissionGeneration(float DifficultyLevel, const class FString& GeneratorName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ExecuteNewMissionGeneration");

	Params::FortCheatManager_ExecuteNewMissionGeneration Parms{};

	Parms.DifficultyLevel = DifficultyLevel;
	Parms.GeneratorName = std::move(GeneratorName);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.FakeZoneScoreboard
// (Final, Exec, Native, Public)

void UFortCheatManager::FakeZoneScoreboard()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "FakeZoneScoreboard");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceAILODs
// (Final, Exec, Native, Public)
// Parameters:
// EFortAILODLevel                         inForcedAILODValue                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ForceAILODs(EFortAILODLevel inForcedAILODValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceAILODs");

	Params::FortCheatManager_ForceAILODs Parms{};

	Parms.inForcedAILODValue = inForcedAILODValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceHeroType
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    HeroPersistentName                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ForceHeroType(const class FString& HeroPersistentName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceHeroType");

	Params::FortCheatManager_ForceHeroType Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceNakedOutfit
// (Final, Exec, Native, Public)

void UFortCheatManager::ForceNakedOutfit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceNakedOutfit");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceSaveMissionStateAndWorld
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SaveFilename                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ForceSaveMissionStateAndWorld(const class FString& SaveFilename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceSaveMissionStateAndWorld");

	Params::FortCheatManager_ForceSaveMissionStateAndWorld Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceSaveWorld
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SaveFilename                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ForceSaveWorld(const class FString& SaveFilename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceSaveWorld");

	Params::FortCheatManager_ForceSaveWorld Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceSetHeroRemoteCharacter
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   PartyMemberIndex                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::ForceSetHeroRemoteCharacter(int32 PartyMemberIndex, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceSetHeroRemoteCharacter");

	Params::FortCheatManager_ForceSetHeroRemoteCharacter Parms{};

	Parms.PartyMemberIndex = PartyMemberIndex;
	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ForceShowScoreboard
// (Final, Exec, Native, Public)

void UFortCheatManager::ForceShowScoreboard()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ForceShowScoreboard");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GeneratePolysInPathingRange
// (Final, Exec, Native, Public)
// Parameters:
// float                                   MaxDistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MinDistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GeneratePolysInPathingRange(float MaxDistance, float MinDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GeneratePolysInPathingRange");

	Params::FortCheatManager_GeneratePolysInPathingRange Parms{};

	Parms.MaxDistance = MaxDistance;
	Parms.MinDistance = MinDistance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetAllReplStats
// (Final, Exec, Native, Public)

void UFortCheatManager::GetAllReplStats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetAllReplStats");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetFocusedMissionInfo
// (Final, Exec, Native, Public)

void UFortCheatManager::GetFocusedMissionInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetFocusedMissionInfo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetGameStat
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    StatName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GetGameStat(const class FString& StatName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetGameStat");

	Params::FortCheatManager_GetGameStat Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetReplStat
// (Final, Exec, Native, Public)
// Parameters:
// EFortReplicatedStat                     Stat                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GetReplStat(EFortReplicatedStat Stat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetReplStat");

	Params::FortCheatManager_GetReplStat Parms{};

	Parms.Stat = Stat;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetWorldDifficulty
// (Final, Exec, Native, Public)

void UFortCheatManager::GetWorldDifficulty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetWorldDifficulty");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetWorldLevel
// (Final, Exec, Native, Public)

void UFortCheatManager::GetWorldLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetWorldLevel");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetWorldLockStatus
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    WUID                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GetWorldLockStatus(const class FString& WUID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetWorldLockStatus");

	Params::FortCheatManager_GetWorldLockStatus Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GetWTFRotations
// (Final, Exec, Native, Public)

void UFortCheatManager::GetWTFRotations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GetWTFRotations");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllConsumables
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumItems                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveAllConsumables(int32 NumItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllConsumables");

	Params::FortCheatManager_GiveAllConsumables Parms{};

	Parms.NumItems = NumItems;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllDecorations
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllDecorations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllDecorations");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllIngredients
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumIngredients                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveAllIngredients(int32 NumIngredients)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllIngredients");

	Params::FortCheatManager_GiveAllIngredients Parms{};

	Parms.NumIngredients = NumIngredients;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllMelee
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllMelee()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllMelee");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllPistols
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllPistols()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllPistols");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllRifles
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllRifles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllRifles");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllShotguns
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllShotguns()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllShotguns");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllTraps
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumItems                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveAllTraps(int32 NumItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllTraps");

	Params::FortCheatManager_GiveAllTraps Parms{};

	Parms.NumItems = NumItems;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAllWeapons
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveAllWeapons()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAllWeapons");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveAmmo
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    AmmoNameAndAmmount                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveAmmo(const class FString& AmmoNameAndAmmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveAmmo");

	Params::FortCheatManager_GiveAmmo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveBluGlo
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveBluGlo(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveBluGlo");

	Params::FortCheatManager_GiveBluGlo Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveCheatInventory
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveCheatInventory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveCheatInventory");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveFakeBuildingGameplayEffect
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    BuildingTemplateId                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveFakeBuildingGameplayEffect(const class FString& BuildingTemplateId, int32 Level)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveFakeBuildingGameplayEffect");

	Params::FortCheatManager_GiveFakeBuildingGameplayEffect Parms{};

	Parms.BuildingTemplateId = std::move(BuildingTemplateId);
	Parms.Level = Level;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveGadget
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    GadgetName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveGadget(const class FString& GadgetName, int32 ItemLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveGadget");

	Params::FortCheatManager_GiveGadget Parms{};

	Parms.GadgetName = std::move(GadgetName);
	Parms.ItemLevel = ItemLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveGadgets
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    GadgetName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Quantity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveGadgets(const class FString& GadgetName, int32 Quantity, int32 ItemLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveGadgets");

	Params::FortCheatManager_GiveGadgets Parms{};

	Parms.GadgetName = std::move(GadgetName);
	Parms.Quantity = Quantity;
	Parms.ItemLevel = ItemLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveGoodWeapons
// (Final, Exec, Native, Public)

void UFortCheatManager::GiveGoodWeapons()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveGoodWeapons");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveHeroSpecialization
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SpecializationName                                     (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveHeroSpecialization(const class FString& SpecializationName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveHeroSpecialization");

	Params::FortCheatManager_GiveHeroSpecialization Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveMetal
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveMetal(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveMetal");

	Params::FortCheatManager_GiveMetal Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveResources
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveResources(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveResources");

	Params::FortCheatManager_GiveResources Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveSBA
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    StrategicBuildingName                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveSBA(const class FString& StrategicBuildingName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveSBA");

	Params::FortCheatManager_GiveSBA Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveSpecificItem
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ItemPath                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveSpecificItem(const class FString& ItemPath, int32 ItemLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveSpecificItem");

	Params::FortCheatManager_GiveSpecificItem Parms{};

	Parms.ItemPath = std::move(ItemPath);
	Parms.ItemLevel = ItemLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveStone
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveStone(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveStone");

	Params::FortCheatManager_GiveStone Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveTrap
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    TrapName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RequestedLevel                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveTrap(const class FString& TrapName, int32 RequestedLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveTrap");

	Params::FortCheatManager_GiveTrap Parms{};

	Parms.TrapName = std::move(TrapName);
	Parms.RequestedLevel = RequestedLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveUsefulThings
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumOfUsefulThings                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveUsefulThings(int32 NumOfUsefulThings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveUsefulThings");

	Params::FortCheatManager_GiveUsefulThings Parms{};

	Parms.NumOfUsefulThings = NumOfUsefulThings;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveWeapon
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    WeaponName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   RequestedLevel                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveWeapon(const class FString& WeaponName, int32 RequestedLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveWeapon");

	Params::FortCheatManager_GiveWeapon Parms{};

	Parms.WeaponName = std::move(WeaponName);
	Parms.RequestedLevel = RequestedLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveWeapons
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Tag                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveWeapons(class FName Tag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveWeapons");

	Params::FortCheatManager_GiveWeapons Parms{};

	Parms.Tag = Tag;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.GiveWood
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::GiveWood(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "GiveWood");

	Params::FortCheatManager_GiveWood Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.KillPawns
// (Exec, Native, Public)
// Parameters:
// TSubclassOf<class AFortPawn>            aClass                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::KillPawns(TSubclassOf<class AFortPawn> aClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "KillPawns");

	Params::FortCheatManager_KillPawns Parms{};

	Parms.aClass = aClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListActiveEncounters
// (Final, Exec, Native, Public)

void UFortCheatManager::ListActiveEncounters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListActiveEncounters");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListAIUtilities
// (Final, Exec, Native, Public)

void UFortCheatManager::ListAIUtilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListAIUtilities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListAmmo
// (Final, Exec, Native, Public)

void UFortCheatManager::ListAmmo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListAmmo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListBannedPlayers
// (Final, Exec, Native, Public)

void UFortCheatManager::ListBannedPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListBannedPlayers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListCheats
// (Final, Exec, Native, Public)

void UFortCheatManager::ListCheats()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListCheats");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListDecorations
// (Final, Exec, Native, Public)

void UFortCheatManager::ListDecorations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListDecorations");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListEmotes
// (Final, Exec, Native, Public)

void UFortCheatManager::ListEmotes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListEmotes");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListEnemyMutators
// (Final, Exec, Native, Public)

void UFortCheatManager::ListEnemyMutators()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListEnemyMutators");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListMissionGenerators
// (Final, Exec, Native, Public)

void UFortCheatManager::ListMissionGenerators()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListMissionGenerators");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListMissions
// (Final, Exec, Native, Public)

void UFortCheatManager::ListMissions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListMissions");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListSpawnGroups
// (Final, Exec, Native, Public)

void UFortCheatManager::ListSpawnGroups()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListSpawnGroups");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.LoadMission
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    MissionName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::LoadMission(const class FString& MissionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "LoadMission");

	Params::FortCheatManager_LoadMission Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.LoadMissionGenerator
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    GeneratorName                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::LoadMissionGenerator(const class FString& GeneratorName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "LoadMissionGenerator");

	Params::FortCheatManager_LoadMissionGenerator Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpApplyAlteration
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    Schematic                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Alteration                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpApplyAlteration(const class FString& Schematic, const class FString& Alteration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpApplyAlteration");

	Params::FortCheatManager_McpApplyAlteration Parms{};

	Parms.Schematic = std::move(Schematic);
	Parms.Alteration = std::move(Alteration);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpCheat
// (Final, Exec, Native, Public)

void UFortCheatManager::McpCheat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpCheat");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpCompleteCurrentPrimaryMission
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumMissionPoints                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpCompleteCurrentPrimaryMission(int32 NumMissionPoints)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpCompleteCurrentPrimaryMission");

	Params::FortCheatManager_McpCompleteCurrentPrimaryMission Parms{};

	Parms.NumMissionPoints = NumMissionPoints;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpCompleteHexMission
// (Final, Exec, Native, Public)

void UFortCheatManager::McpCompleteHexMission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpCompleteHexMission");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpEarnScore
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   ScoreAmount                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpEarnScore(int32 ScoreAmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpEarnScore");

	Params::FortCheatManager_McpEarnScore Parms{};

	Parms.ScoreAmount = ScoreAmount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpEquipCharCosmetic
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    CharacterId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CosmeticId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CosmeticType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpEquipCharCosmetic(const class FString& CharacterId, const class FString& CosmeticId, int32 CosmeticType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpEquipCharCosmetic");

	Params::FortCheatManager_McpEquipCharCosmetic Parms{};

	Parms.CharacterId = std::move(CharacterId);
	Parms.CosmeticId = std::move(CosmeticId);
	Parms.CosmeticType = CosmeticType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetCachedPersistence
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetCachedPersistence()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetCachedPersistence");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetCurrencyAmount
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetCurrencyAmount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetCurrencyAmount");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetHexMission
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetHexMission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetHexMission");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetPersonnelXP
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetPersonnelXP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetPersonnelXP");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetSchematicXP
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetSchematicXP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetSchematicXP");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGetVersion
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGetVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGetVersion");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGrantAllSchematics
// (Final, Exec, Native, Public)

void UFortCheatManager::McpGrantAllSchematics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGrantAllSchematics");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGrantCurrency
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpGrantCurrency(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGrantCurrency");

	Params::FortCheatManager_McpGrantCurrency Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGrantItem
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ItemId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpGrantItem(const class FString& ItemId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGrantItem");

	Params::FortCheatManager_McpGrantItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGrantPersonnelXP
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpGrantPersonnelXP(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGrantPersonnelXP");

	Params::FortCheatManager_McpGrantPersonnelXP Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpGrantSchematicXP
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpGrantSchematicXP(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpGrantSchematicXP");

	Params::FortCheatManager_McpGrantSchematicXP Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHeroAssignToBuilding
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    HeroName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingType                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIdx                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpHeroAssignToBuilding(const class FString& HeroName, const class FString& BuildingType, int32 SlotIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHeroAssignToBuilding");

	Params::FortCheatManager_McpHeroAssignToBuilding Parms{};

	Parms.HeroName = std::move(HeroName);
	Parms.BuildingType = std::move(BuildingType);
	Parms.SlotIdx = SlotIdx;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHeroCreate
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    HeroType                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Name_0                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpHeroCreate(const class FString& HeroType, const class FString& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHeroCreate");

	Params::FortCheatManager_McpHeroCreate Parms{};

	Parms.HeroType = std::move(HeroType);
	Parms.Name_0 = std::move(Name_0);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHeroDelete
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    HeroName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpHeroDelete(const class FString& HeroName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHeroDelete");

	Params::FortCheatManager_McpHeroDelete Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHeroRename
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    OldHeroName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NewHeroName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpHeroRename(const class FString& OldHeroName, const class FString& NewHeroName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHeroRename");

	Params::FortCheatManager_McpHeroRename Parms{};

	Parms.OldHeroName = std::move(OldHeroName);
	Parms.NewHeroName = std::move(NewHeroName);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHostGetAllPlayerCachedPersistence
// (Final, Exec, Native, Public)

void UFortCheatManager::McpHostGetAllPlayerCachedPersistence()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHostGetAllPlayerCachedPersistence");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHostGetPlayers
// (Final, Exec, Native, Public)

void UFortCheatManager::McpHostGetPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHostGetPlayers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpHostGrantAllPlayersSchematic
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SchematicId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpHostGrantAllPlayersSchematic(const class FString& SchematicId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpHostGrantAllPlayersSchematic");

	Params::FortCheatManager_McpHostGrantAllPlayersSchematic Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpLogout
// (Final, Exec, Native, Public)

void UFortCheatManager::McpLogout()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpLogout");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpOpenCardPack
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    CardPackItemId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SelectionIdx                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpOpenCardPack(const class FString& CardPackItemId, int32 SelectionIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpOpenCardPack");

	Params::FortCheatManager_McpOpenCardPack Parms{};

	Parms.CardPackItemId = std::move(CardPackItemId);
	Parms.SelectionIdx = SelectionIdx;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpRecycleItem
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ItemToRecycle                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpRecycleItem(const class FString& ItemToRecycle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpRecycleItem");

	Params::FortCheatManager_McpRecycleItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpRedeemPurchases
// (Final, Exec, Native, Public)

void UFortCheatManager::McpRedeemPurchases()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpRedeemPurchases");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpRefreshCatalog
// (Final, Exec, Native, Public)

void UFortCheatManager::McpRefreshCatalog()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpRefreshCatalog");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpRefreshProfile
// (Final, Exec, Native, Public)

void UFortCheatManager::McpRefreshProfile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpRefreshProfile");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpResetPersistence
// (Final, Exec, Native, Public)

void UFortCheatManager::McpResetPersistence()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpResetPersistence");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.McpUpgradeItem
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ItemToUpgrade                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::McpUpgradeItem(const class FString& ItemToUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "McpUpgradeItem");

	Params::FortCheatManager_McpUpgradeItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MissionForceFailure
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    MissionName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MissionForceFailure(const class FString& MissionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MissionForceFailure");

	Params::FortCheatManager_MissionForceFailure Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MissionForcePrimarySuccess
// (Final, Exec, Native, Public)

void UFortCheatManager::MissionForcePrimarySuccess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MissionForcePrimarySuccess");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MissionForceSuccess
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    MissionName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MissionForceSuccess(const class FString& MissionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MissionForceSuccess");

	Params::FortCheatManager_MissionForceSuccess Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ModItemDurability
// (Final, Exec, Native, Public)
// Parameters:
// float                                   InValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ModItemDurability(float InValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ModItemDurability");

	Params::FortCheatManager_ModItemDurability Parms{};

	Parms.InValue = InValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortAddHeroSlot
// (Final, Exec, Native, Public)

void UFortCheatManager::MyFortAddHeroSlot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortAddHeroSlot");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortAddWorker
// (Final, Exec, Native, Public)

void UFortCheatManager::MyFortAddWorker()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortAddWorker");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortCollectAccumulatedResources
// (Final, Exec, Native, Public)
// Parameters:
// EFortPersistentResources                ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortCollectAccumulatedResources(EFortPersistentResources ResourceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortCollectAccumulatedResources");

	Params::FortCheatManager_MyFortCollectAccumulatedResources Parms{};

	Parms.ResourceType = ResourceType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortConsumeAllResources
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortConsumeAllResources(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortConsumeAllResources");

	Params::FortCheatManager_MyFortConsumeAllResources Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortConsumeResources
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortPersistentResources                ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortConsumeResources(int32 Amount, EFortPersistentResources ResourceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortConsumeResources");

	Params::FortCheatManager_MyFortConsumeResources Parms{};

	Parms.Amount = Amount;
	Parms.ResourceType = ResourceType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortFillWarehouse
// (Final, Exec, Native, Public)
// Parameters:
// EFortPersistentResources                ResourceType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortFillWarehouse(EFortPersistentResources ResourceType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortFillWarehouse");

	Params::FortCheatManager_MyFortFillWarehouse Parms{};

	Parms.ResourceType = ResourceType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortGrantAllResources
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortGrantAllResources(int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortGrantAllResources");

	Params::FortCheatManager_MyFortGrantAllResources Parms{};

	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortRequestUpdate
// (Final, Exec, Native, Public)

void UFortCheatManager::MyFortRequestUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortRequestUpdate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortSetChecksDisabled
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortSetChecksDisabled(bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortSetChecksDisabled");

	Params::FortCheatManager_MyFortSetChecksDisabled Parms{};

	Parms.bSet = bSet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortTestDefaultHeroId
// (Final, Exec, Native, Public)

void UFortCheatManager::MyFortTestDefaultHeroId()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortTestDefaultHeroId");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortTestLastRatings
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    BuildingId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LastMaxLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LastMaxRating                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortTestLastRatings(const class FString& BuildingId, int32 LastMaxLevel, int32 LastMaxRating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortTestLastRatings");

	Params::FortCheatManager_MyFortTestLastRatings Parms{};

	Parms.BuildingId = std::move(BuildingId);
	Parms.LastMaxLevel = LastMaxLevel;
	Parms.LastMaxRating = LastMaxRating;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyFortUpgradeBuilding
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    BuildingId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyFortUpgradeBuilding(const class FString& BuildingId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyFortUpgradeBuilding");

	Params::FortCheatManager_MyFortUpgradeBuilding Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyTownToggleBetweenKeepAndManor
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bNowShowKeep                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::MyTownToggleBetweenKeepAndManor(bool bNowShowKeep)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyTownToggleBetweenKeepAndManor");

	Params::FortCheatManager_MyTownToggleBetweenKeepAndManor Parms{};

	Parms.bNowShowKeep = bNowShowKeep;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.MyTownToggleFriendsHomeBase
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    FriendsAccountId                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    FriendsName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::MyTownToggleFriendsHomeBase(const class FString& FriendsAccountId, const class FString& FriendsName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "MyTownToggleFriendsHomeBase");

	Params::FortCheatManager_MyTownToggleFriendsHomeBase Parms{};

	Parms.FriendsAccountId = std::move(FriendsAccountId);
	Parms.FriendsName = std::move(FriendsName);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.OpenClassSelectScreen
// (Final, Exec, Native, Public)

void UFortCheatManager::OpenClassSelectScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "OpenClassSelectScreen");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.PrintShotReport
// (Final, Exec, Native, Public)

void UFortCheatManager::PrintShotReport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "PrintShotReport");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.PrintTileWorld
// (Final, Exec, Native, Public)

void UFortCheatManager::PrintTileWorld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "PrintTileWorld");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.RefreshTheaters
// (Final, Exec, Native, Public)

void UFortCheatManager::RefreshTheaters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "RefreshTheaters");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.RegenerateZoneMissions
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bUseNewMissionGeneration                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::RegenerateZoneMissions(bool bUseNewMissionGeneration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "RegenerateZoneMissions");

	Params::FortCheatManager_RegenerateZoneMissions Parms{};

	Parms.bUseNewMissionGeneration = bUseNewMissionGeneration;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.RegenerateZoneMissionsWithDifficultyLevel
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bUseNewMissionGeneration                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DifficultyLevelOverride                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::RegenerateZoneMissionsWithDifficultyLevel(bool bUseNewMissionGeneration, float DifficultyLevelOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "RegenerateZoneMissionsWithDifficultyLevel");

	Params::FortCheatManager_RegenerateZoneMissionsWithDifficultyLevel Parms{};

	Parms.bUseNewMissionGeneration = bUseNewMissionGeneration;
	Parms.DifficultyLevelOverride = DifficultyLevelOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ReInitHUD
// (Final, Exec, Native, Public)

void UFortCheatManager::ReInitHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ReInitHUD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ReloadUI
// (Final, Exec, Native, Public)

void UFortCheatManager::ReloadUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ReloadUI");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ReloadUMG
// (Final, Exec, Native, Public)

void UFortCheatManager::ReloadUMG()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ReloadUMG");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ReRandomizeTiles
// (Final, Exec, Native, Public)

void UFortCheatManager::ReRandomizeTiles()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ReRandomizeTiles");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ResetEncounterWave
// (Final, Exec, Native, Public)

void UFortCheatManager::ResetEncounterWave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ResetEncounterWave");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ResetMaxAITracking
// (Final, Exec, Native, Public)

void UFortCheatManager::ResetMaxAITracking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ResetMaxAITracking");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.RunMonteCarlo
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    TileGroup                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumIterations                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::RunMonteCarlo(int32 X, int32 Y, const class FString& TileGroup, int32 NumIterations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "RunMonteCarlo");

	Params::FortCheatManager_RunMonteCarlo Parms{};

	Parms.X = X;
	Parms.Y = Y;
	Parms.TileGroup = std::move(TileGroup);
	Parms.NumIterations = NumIterations;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SendCheatNotifications
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumOfNotifications                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SendCheatNotifications(int32 NumOfNotifications)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SendCheatNotifications");

	Params::FortCheatManager_SendCheatNotifications Parms{};

	Parms.NumOfNotifications = NumOfNotifications;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SendMissionEvent
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    MissionEventName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SendMissionEvent(const class FString& MissionEventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SendMissionEvent");

	Params::FortCheatManager_SendMissionEvent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SendQuestEvent
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TargetTag                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SourceTag                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ContextTag                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SendQuestEvent(class FName Type, class FName TargetTag, class FName SourceTag, class FName ContextTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SendQuestEvent");

	Params::FortCheatManager_SendQuestEvent Parms{};

	Parms.Type = Type;
	Parms.TargetTag = TargetTag;
	Parms.SourceTag = SourceTag;
	Parms.ContextTag = ContextTag;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetActionMappingEnabled
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Action                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::SetActionMappingEnabled(class FName Action, bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetActionMappingEnabled");

	Params::FortCheatManager_SetActionMappingEnabled Parms{};

	Parms.Action = Action;
	Parms.bEnabled = bEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetAimMode
// (Final, Exec, Native, Public)
// Parameters:
// uint32                                  Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetAimMode(uint32 Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetAimMode");

	Params::FortCheatManager_SetAimMode Parms{};

	Parms.Mode = Mode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetBaseScaleLevelOverride
// (Final, Exec, Native, Public)
// Parameters:
// float                                   BaseScaleLevelOverrideValue                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetBaseScaleLevelOverride(float BaseScaleLevelOverrideValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetBaseScaleLevelOverride");

	Params::FortCheatManager_SetBaseScaleLevelOverride Parms{};

	Parms.BaseScaleLevelOverrideValue = BaseScaleLevelOverrideValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetBTProbability
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Propability                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetBTProbability(float Propability)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetBTProbability");

	Params::FortCheatManager_SetBTProbability Parms{};

	Parms.Propability = Propability;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetBuildAnimCheatHeight
// (Exec, Native, Public)
// Parameters:
// float                                   NewHeight                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetBuildAnimCheatHeight(float NewHeight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetBuildAnimCheatHeight");

	Params::FortCheatManager_SetBuildAnimCheatHeight Parms{};

	Parms.NewHeight = NewHeight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetBuildAnimCheatSpeedMultiplier
// (Exec, Native, Public)
// Parameters:
// float                                   NewMultiplier                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetBuildAnimCheatSpeedMultiplier(float NewMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetBuildAnimCheatSpeedMultiplier");

	Params::FortCheatManager_SetBuildAnimCheatSpeedMultiplier Parms{};

	Parms.NewMultiplier = NewMultiplier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetBuildAnimCheatStartDelay
// (Exec, Native, Public)
// Parameters:
// float                                   MaxRandDelay                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetBuildAnimCheatStartDelay(float MaxRandDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetBuildAnimCheatStartDelay");

	Params::FortCheatManager_SetBuildAnimCheatStartDelay Parms{};

	Parms.MaxRandDelay = MaxRandDelay;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCameraDistanceMultiplier
// (Final, Exec, Native, Public)
// Parameters:
// float                                   XMultiplier                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   YMultiplier                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ZMultiplier                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCameraDistanceMultiplier(float XMultiplier, float YMultiplier, float ZMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCameraDistanceMultiplier");

	Params::FortCheatManager_SetCameraDistanceMultiplier Parms{};

	Parms.XMultiplier = XMultiplier;
	Parms.YMultiplier = YMultiplier;
	Parms.ZMultiplier = ZMultiplier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCameraFOVMultiplier
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Multiplier                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCameraFOVMultiplier(float Multiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCameraFOVMultiplier");

	Params::FortCheatManager_SetCameraFOVMultiplier Parms{};

	Parms.Multiplier = Multiplier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCameraPrototype
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             ProtoName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCameraPrototype(class FName ProtoName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCameraPrototype");

	Params::FortCheatManager_SetCameraPrototype Parms{};

	Parms.ProtoName = ProtoName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCapturePercentage
// (Final, Exec, Native, Public)
// Parameters:
// float                                   NewCapturePercentage                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCapturePercentage(float NewCapturePercentage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCapturePercentage");

	Params::FortCheatManager_SetCapturePercentage Parms{};

	Parms.NewCapturePercentage = NewCapturePercentage;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCombatGraphHistoryLength
// (Exec, Native, Public)
// Parameters:
// int32                                   Seconds                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCombatGraphHistoryLength(int32 Seconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCombatGraphHistoryLength");

	Params::FortCheatManager_SetCombatGraphHistoryLength Parms{};

	Parms.Seconds = Seconds;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCullValues
// (Final, Exec, Native, Public)
// Parameters:
// float                                   DefaultCullObjectSize                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DefaultCullDistance                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MinCullObjectSize                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MinCullDistance                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxCullObjectSize                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxCullDistance                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCullValues(float DefaultCullObjectSize, float DefaultCullDistance, float MinCullObjectSize, float MinCullDistance, float MaxCullObjectSize, float MaxCullDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCullValues");

	Params::FortCheatManager_SetCullValues Parms{};

	Parms.DefaultCullObjectSize = DefaultCullObjectSize;
	Parms.DefaultCullDistance = DefaultCullDistance;
	Parms.MinCullObjectSize = MinCullObjectSize;
	Parms.MinCullDistance = MinCullDistance;
	Parms.MaxCullObjectSize = MaxCullObjectSize;
	Parms.MaxCullDistance = MaxCullDistance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetCurrentEncounterToDebug
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   EncounterIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetCurrentEncounterToDebug(int32 EncounterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetCurrentEncounterToDebug");

	Params::FortCheatManager_SetCurrentEncounterToDebug Parms{};

	Parms.EncounterIndex = EncounterIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterDirections
// (Final, Exec, Native, Public)
// Parameters:
// const TArray<EFortEncounterDirection>&  Directions                                             (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterDirections(const TArray<EFortEncounterDirection>& Directions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterDirections");

	Params::FortCheatManager_SetEncounterDirections Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterGraphsHistoryLength
// (Exec, Native, Public)
// Parameters:
// int32                                   Seconds                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterGraphsHistoryLength(int32 Seconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterGraphsHistoryLength");

	Params::FortCheatManager_SetEncounterGraphsHistoryLength Parms{};

	Parms.Seconds = Seconds;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterSimulatedNumberOfPlayers
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumPlayers                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterSimulatedNumberOfPlayers(int32 NumPlayers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterSimulatedNumberOfPlayers");

	Params::FortCheatManager_SetEncounterSimulatedNumberOfPlayers Parms{};

	Parms.NumPlayers = NumPlayers;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterSpawnPointsCap
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   SpawnPointsCap                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterSpawnPointsCap(int32 SpawnPointsCap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterSpawnPointsCap");

	Params::FortCheatManager_SetEncounterSpawnPointsCap Parms{};

	Parms.SpawnPointsCap = SpawnPointsCap;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterSpawnPointsCurve
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    CurveName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterSpawnPointsCurve(const class FString& CurveName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterSpawnPointsCurve");

	Params::FortCheatManager_SetEncounterSpawnPointsCurve Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetEncounterTopUtilityPercentages
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    UtilitiesAndPercentages                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetEncounterTopUtilityPercentages(const class FString& UtilitiesAndPercentages)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetEncounterTopUtilityPercentages");

	Params::FortCheatManager_SetEncounterTopUtilityPercentages Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetGameDifficultyOverride
// (Final, Exec, Native, Public)
// Parameters:
// float                                   GameDifficultyOverrideValue                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetGameDifficultyOverride(float GameDifficultyOverrideValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetGameDifficultyOverride");

	Params::FortCheatManager_SetGameDifficultyOverride Parms{};

	Parms.GameDifficultyOverrideValue = GameDifficultyOverrideValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetGameStat
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    StatName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetGameStat(const class FString& StatName, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetGameStat");

	Params::FortCheatManager_SetGameStat Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetHealthPercent
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Percent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetHealthPercent(float Percent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetHealthPercent");

	Params::FortCheatManager_SetHealthPercent Parms{};

	Parms.Percent = Percent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetInteractExtent
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Extent                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetInteractExtent(float Extent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetInteractExtent");

	Params::FortCheatManager_SetInteractExtent Parms{};

	Parms.Extent = Extent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetInteractionDistances
// (Final, Exec, Native, Public)
// Parameters:
// float                                   InteractionDistance                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InteractionHighlightDistance                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetInteractionDistances(float InteractionDistance, float InteractionHighlightDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetInteractionDistances");

	Params::FortCheatManager_SetInteractionDistances Parms{};

	Parms.InteractionDistance = InteractionDistance;
	Parms.InteractionHighlightDistance = InteractionHighlightDistance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetJumpStaminaCost
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             ModeName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetJumpStaminaCost(class FName ModeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetJumpStaminaCost");

	Params::FortCheatManager_SetJumpStaminaCost Parms{};

	Parms.ModeName = ModeName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetMaxClouds
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   MaxClouds                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetMaxClouds(int32 MaxClouds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetMaxClouds");

	Params::FortCheatManager_SetMaxClouds Parms{};

	Parms.MaxClouds = MaxClouds;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetPvPRoundTime
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumSeconds                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CriticalThreshold                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetPvPRoundTime(int32 NumSeconds, int32 CriticalThreshold)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetPvPRoundTime");

	Params::FortCheatManager_SetPvPRoundTime Parms{};

	Parms.NumSeconds = NumSeconds;
	Parms.CriticalThreshold = CriticalThreshold;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetPvPStalemateTime
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NumSeconds                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetPvPStalemateTime(int32 NumSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetPvPStalemateTime");

	Params::FortCheatManager_SetPvPStalemateTime Parms{};

	Parms.NumSeconds = NumSeconds;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetReplStat
// (Final, Exec, Native, Public)
// Parameters:
// EFortReplicatedStat                     Stat                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Amount                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetReplStat(EFortReplicatedStat Stat, int32 Amount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetReplStat");

	Params::FortCheatManager_SetReplStat Parms{};

	Parms.Stat = Stat;
	Parms.Amount = Amount;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetRespawnTimerOverride
// (Final, Exec, Native, Public)
// Parameters:
// float                                   TimeUntilRespawn                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetRespawnTimerOverride(float TimeUntilRespawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetRespawnTimerOverride");

	Params::FortCheatManager_SetRespawnTimerOverride Parms{};

	Parms.TimeUntilRespawn = TimeUntilRespawn;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetWorldDaysElapsed
// (Final, Exec, Native, Public)
// Parameters:
// float                                   days                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetWorldDaysElapsed(float days)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetWorldDaysElapsed");

	Params::FortCheatManager_SetWorldDaysElapsed Parms{};

	Parms.days = days;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SetWorldLevel
// (Final, Exec, Native, Public)
// Parameters:
// float                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SetWorldLevel(float Level)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SetWorldLevel");

	Params::FortCheatManager_SetWorldLevel Parms{};

	Parms.Level = Level;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SimulateLoot
// (Final, Exec, Native, Public)
// Parameters:
// const class FName                       TierGroup                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LootTier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SimulateLoot(const class FName TierGroup, int32 LootTier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SimulateLoot");

	Params::FortCheatManager_SimulateLoot Parms{};

	Parms.TierGroup = TierGroup;
	Parms.LootTier = LootTier;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SimulateLootDrops
// (Final, Exec, Native, Public)

void UFortCheatManager::SimulateLootDrops()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SimulateLootDrops");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SpawnAIGroup
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SpawnGroupName                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SpawnAIGroup(const class FString& SpawnGroupName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SpawnAIGroup");

	Params::FortCheatManager_SpawnAIGroup Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SpawnAIGroupFromExternalSpawner
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SpawnGroupName                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SpawnAIGroupFromExternalSpawner(const class FString& SpawnGroupName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SpawnAIGroupFromExternalSpawner");

	Params::FortCheatManager_SpawnAIGroupFromExternalSpawner Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SpawnAIGroupWithMutator
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    SpawnGroupName                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MutatorName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   DummyInt                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SpawnAIGroupWithMutator(const class FString& SpawnGroupName, const class FString& MutatorName, int32 DummyInt)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SpawnAIGroupWithMutator");

	Params::FortCheatManager_SpawnAIGroupWithMutator Parms{};

	Parms.SpawnGroupName = std::move(SpawnGroupName);
	Parms.MutatorName = std::move(MutatorName);
	Parms.DummyInt = DummyInt;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SpawnGuardians
// (Final, Exec, Native, Public)

void UFortCheatManager::SpawnGuardians()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SpawnGuardians");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SpawnPawn
// (Exec, Native, Public)
// Parameters:
// const class FString&                    PawnType                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPawn* UFortCheatManager::SpawnPawn(const class FString& PawnType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SpawnPawn");

	Params::FortCheatManager_SpawnPawn Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCheatManager.StopDummyDebugEncounter
// (Final, Exec, Native, Public)

void UFortCheatManager::StopDummyDebugEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "StopDummyDebugEncounter");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SwitchHeroToClass
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    NewHeroID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::SwitchHeroToClass(const class FString& NewHeroID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SwitchHeroToClass");

	Params::FortCheatManager_SwitchHeroToClass Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.SwitchTeam
// (Final, Exec, Native, Public)

void UFortCheatManager::SwitchTeam()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "SwitchTeam");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TeleportToActor
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ClassOrInstanceName                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TeleportToActor(const class FString& ClassOrInstanceName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TeleportToActor");

	Params::FortCheatManager_TeleportToActor Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TeleportToLocation
// (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)

void UFortCheatManager::TeleportToLocation(float X, float Y, float Z)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TeleportToLocation");

	Params::FortCheatManager_TeleportToLocation Parms{};

	Parms.X = X;
	Parms.Y = Y;
	Parms.Z = Z;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TeleportToMissionActor
// (Final, Exec, Native, Public)

void UFortCheatManager::TeleportToMissionActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TeleportToMissionActor");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestCancelLobby
// (Final, Exec, Native, Public)

void UFortCheatManager::TestCancelLobby()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestCancelLobby");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestChangePartyPrivacy
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bPrivate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bLeaderFriendsOnly                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bLeaderInvitesOnly                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::TestChangePartyPrivacy(bool bPrivate, bool bLeaderFriendsOnly, bool bLeaderInvitesOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestChangePartyPrivacy");

	Params::FortCheatManager_TestChangePartyPrivacy Parms{};

	Parms.bPrivate = bPrivate;
	Parms.bLeaderFriendsOnly = bLeaderFriendsOnly;
	Parms.bLeaderInvitesOnly = bLeaderInvitesOnly;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestChangePartySize
// (Final, Exec, Native, Public)
// Parameters:
// int32                                   NewSize                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TestChangePartySize(int32 NewSize)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestChangePartySize");

	Params::FortCheatManager_TestChangePartySize Parms{};

	Parms.NewSize = NewSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestDisconnect
// (Final, Exec, Native, Public)

void UFortCheatManager::TestDisconnect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestDisconnect");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestFogLoad
// (Final, Exec, Native, Public)

void UFortCheatManager::TestFogLoad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestFogLoad");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestFogReplicate
// (Final, Exec, Native, Public)

void UFortCheatManager::TestFogReplicate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestFogReplicate");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestFogSave
// (Final, Exec, Native, Public)

void UFortCheatManager::TestFogSave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestFogSave");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestJoin
// (Final, Exec, Native, Public)

void UFortCheatManager::TestJoin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestJoin");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestKnockback
// (Final, Exec, Native, Public)
// Parameters:
// float                                   KnockbackMagnitude                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KnockbackZAngle                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TestKnockback(float KnockbackMagnitude, float KnockbackZAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestKnockback");

	Params::FortCheatManager_TestKnockback Parms{};

	Parms.KnockbackMagnitude = KnockbackMagnitude;
	Parms.KnockbackZAngle = KnockbackZAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestLeaveGame
// (Final, Exec, Native, Public)

void UFortCheatManager::TestLeaveGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestLeaveGame");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestLockWorld
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    WUID                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLock                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::TestLockWorld(const class FString& WUID, bool bLock)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestLockWorld");

	Params::FortCheatManager_TestLockWorld Parms{};

	Parms.WUID = std::move(WUID);
	Parms.bLock = bLock;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestOutpostUI
// (Final, Exec, Native, Public)

void UFortCheatManager::TestOutpostUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestOutpostUI");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestSetOutpostDefenseActive
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortCheatManager::TestSetOutpostDefenseActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestSetOutpostDefenseActive");

	Params::FortCheatManager_TestSetOutpostDefenseActive Parms{};

	Parms.bActive = bActive;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestStun
// (Final, Exec, Native, Public)
// Parameters:
// float                                   StunStime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TestStun(float StunStime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestStun");

	Params::FortCheatManager_TestStun Parms{};

	Parms.StunStime = StunStime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TestUpgradeOutpostItem
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    ItemTemplateId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TestUpgradeOutpostItem(const class FString& ItemTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TestUpgradeOutpostItem");

	Params::FortCheatManager_TestUpgradeOutpostItem Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleAIAnim
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleAIAnim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleAIAnim");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleAIDespawning
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleAIDespawning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleAIDespawning");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleAIDirectorLogging
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleAIDirectorLogging()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleAIDirectorLogging");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleAISpawnCap
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleAISpawnCap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleAISpawnCap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleAISpawning
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleAISpawning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleAISpawning");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleBuildAnimCheat
// (Exec, Native, Public)

void UFortCheatManager::ToggleBuildAnimCheat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleBuildAnimCheat");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleBuildingActorsTransparency
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleBuildingActorsTransparency()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleBuildingActorsTransparency");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleCombatGraph
// (Exec, Native, Public)

void UFortCheatManager::ToggleCombatGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleCombatGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleDrawRunVariationDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleDrawRunVariationDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleDrawRunVariationDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleDrawTargetSelectionDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleDrawTargetSelectionDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleDrawTargetSelectionDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleDrawTargetSelectionDebugByClass
// (Final, Exec, Native, Public)
// Parameters:
// TSubclassOf<class AActor>               TargetSelectionDebugSourceClass                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::ToggleDrawTargetSelectionDebugByClass(TSubclassOf<class AActor> TargetSelectionDebugSourceClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleDrawTargetSelectionDebugByClass");

	Params::FortCheatManager_ToggleDrawTargetSelectionDebugByClass Parms{};

	Parms.TargetSelectionDebugSourceClass = TargetSelectionDebugSourceClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleDrawTurnTransitionDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleDrawTurnTransitionDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleDrawTurnTransitionDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleEncounterEQSDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleEncounterEQSDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleEncounterEQSDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleFactorGraph
// (Exec, Native, Public)

void UFortCheatManager::ToggleFactorGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleFactorGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleFloorsOnMiniMap
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleFloorsOnMiniMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleFloorsOnMiniMap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleFreezeAILOD
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleFreezeAILOD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleFreezeAILOD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleGameDifficultyHUD
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleGameDifficultyHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleGameDifficultyHUD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleIndestructibleKeep
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleIndestructibleKeep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleIndestructibleKeep");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleInfiniteAmmo
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleInfiniteAmmo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleInfiniteAmmo");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleInfiniteDurability
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleInfiniteDurability()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleInfiniteDurability");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleInfiniteStamina
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleInfiniteStamina()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleInfiniteStamina");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleIntensityGraph
// (Exec, Native, Public)

void UFortCheatManager::ToggleIntensityGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleIntensityGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleIntensityHUD
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleIntensityHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleIntensityHUD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleInteractTrace
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleInteractTrace()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleInteractTrace");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleInvincibleCornerstones
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleInvincibleCornerstones()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleInvincibleCornerstones");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleLogCharacterCustomization
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleLogCharacterCustomization()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleLogCharacterCustomization");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleMaxAIHUD
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleMaxAIHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleMaxAIHUD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleNoCoolDown
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleNoCoolDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleNoCoolDown");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TogglePickupSpline
// (Final, Exec, Native, Public)

void UFortCheatManager::TogglePickupSpline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TogglePickupSpline");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TogglePIDContributionsGraph
// (Exec, Native, Public)

void UFortCheatManager::TogglePIDContributionsGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TogglePIDContributionsGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TogglePIDValuesGraph
// (Exec, Native, Public)

void UFortCheatManager::TogglePIDValuesGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TogglePIDValuesGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TogglePlayerNames
// (Exec, Native, Public)

void UFortCheatManager::TogglePlayerNames()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TogglePlayerNames");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleShotLogging
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleShotLogging()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleShotLogging");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleSpawnPATrolls
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleSpawnPATrolls()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleSpawnPATrolls");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleSpawnPointsHUD
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleSpawnPointsHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleSpawnPointsHUD");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleTreeVisibility
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleTreeVisibility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleTreeVisibility");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleUnlimitedHealth
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleUnlimitedHealth()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleUnlimitedHealth");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleUtilitiesGraph
// (Exec, Native, Public)

void UFortCheatManager::ToggleUtilitiesGraph()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleUtilitiesGraph");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleVoiceDebug
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleVoiceDebug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleVoiceDebug");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ToggleWalkOnWalls
// (Final, Exec, Native, Public)

void UFortCheatManager::ToggleWalkOnWalls()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ToggleWalkOnWalls");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TriggerOutOfStaminaFeedback
// (Final, Exec, Native, Public)

void UFortCheatManager::TriggerOutOfStaminaFeedback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TriggerOutOfStaminaFeedback");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialAddHidden
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Hidden                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TutorialAddHidden(class FName Hidden)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialAddHidden");

	Params::FortCheatManager_TutorialAddHidden Parms{};

	Parms.Hidden = Hidden;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialAddHighlight
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Highlight                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TutorialAddHighlight(class FName Highlight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialAddHighlight");

	Params::FortCheatManager_TutorialAddHighlight Parms{};

	Parms.Highlight = Highlight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialListAll
// (Final, Exec, Native, Public)

void UFortCheatManager::TutorialListAll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialListAll");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialListHidden
// (Final, Exec, Native, Public)

void UFortCheatManager::TutorialListHidden()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialListHidden");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialListHighlights
// (Final, Exec, Native, Public)

void UFortCheatManager::TutorialListHighlights()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialListHighlights");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialRemoveHidden
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Hidden                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TutorialRemoveHidden(class FName Hidden)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialRemoveHidden");

	Params::FortCheatManager_TutorialRemoveHidden Parms{};

	Parms.Hidden = Hidden;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.TutorialRemoveHighlight
// (Final, Exec, Native, Public)
// Parameters:
// class FName                             Highlight                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::TutorialRemoveHighlight(class FName Highlight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "TutorialRemoveHighlight");

	Params::FortCheatManager_TutorialRemoveHighlight Parms{};

	Parms.Highlight = Highlight;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.UnbanPlayer
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    PlayerName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortCheatManager::UnbanPlayer(const class FString& PlayerName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "UnbanPlayer");

	Params::FortCheatManager_UnbanPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.UncoverMap
// (Final, Exec, Native, Public)

void UFortCheatManager::UncoverMap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "UncoverMap");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.UnforceAILODs
// (Final, Exec, Native, Public)

void UFortCheatManager::UnforceAILODs()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "UnforceAILODs");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.UnlockAllZones
// (Final, Exec, Native, Public)

void UFortCheatManager::UnlockAllZones()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "UnlockAllZones");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.UpdateHomebaseGameplayEffects
// (Final, Exec, Native, Public)

void UFortCheatManager::UpdateHomebaseGameplayEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "UpdateHomebaseGameplayEffects");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ViewStuck
// (Final, Exec, Native, Public)

void UFortCheatManager::ViewStuck()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ViewStuck");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.WannaGun
// (Final, Exec, Native, Public)

void UFortCheatManager::WannaGun()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "WannaGun");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.WriteLootReport
// (Final, Exec, Native, Public)

void UFortCheatManager::WriteLootReport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "WriteLootReport");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListGadgets
// (Final, Exec, Native, Public, Const)

void UFortCheatManager::ListGadgets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListGadgets");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListTraps
// (Final, Exec, Native, Public, Const)

void UFortCheatManager::ListTraps() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListTraps");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCheatManager.ListWeapons
// (Final, Exec, Native, Public, Const)

void UFortCheatManager::ListWeapons() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCheatManager", "ListWeapons");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityKit.GetDescription
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FText>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FText> UFortAbilityKit::GetDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityKit", "GetDescription");

	Params::FortAbilityKit_GetDescription Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.CanBeDropped
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::CanBeDropped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "CanBeDropped");

	Params::FortItem_CanBeDropped Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.CanBeUnslotted
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::CanBeUnslotted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "CanBeUnslotted");

	Params::FortItem_CanBeUnslotted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.CanBeUpgraded
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::CanBeUpgraded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "CanBeUpgraded");

	Params::FortItem_CanBeUpgraded Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.DoesMatchSearchString
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    SearchString                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::DoesMatchSearchString(const class FString& SearchString) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "DoesMatchSearchString");

	Params::FortItem_DoesMatchSearchString Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetAlterations
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAlterationItemDefinition*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortAlterationItemDefinition*> UFortItem::GetAlterations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetAlterations");

	Params::FortItem_GetAlterations Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetAlterationSlotActivationRequirement
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItem::GetAlterationSlotActivationRequirement(int32 SlotIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetAlterationSlotActivationRequirement");

	Params::FortItem_GetAlterationSlotActivationRequirement Parms{};

	Parms.SlotIndex = SlotIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetCoolDownPercentageRemaining
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItem::GetCoolDownPercentageRemaining(class AFortPlayerController* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetCoolDownPercentageRemaining");

	Params::FortItem_GetCoolDownPercentageRemaining Parms{};

	Parms.FortPC = FortPC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetCoolDownTimeRemaining
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  CooldownDuration                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItem::GetCoolDownTimeRemaining(class AFortPlayerController* FortPC, float* CooldownDuration) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetCoolDownTimeRemaining");

	Params::FortItem_GetCoolDownTimeRemaining Parms{};

	Parms.FortPC = FortPC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetDescription
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItem::GetDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetDescription");

	Params::FortItem_GetDescription Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetDisplayName
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItem::GetDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetDisplayName");

	Params::FortItem_GetDisplayName Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItem::GetDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetDurability");

	Params::FortItem_GetDurability Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetFilterCategory
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortInventoryFilter                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortInventoryFilter UFortItem::GetFilterCategory() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetFilterCategory");

	Params::FortItem_GetFilterCategory Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetIconBrush
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FSlateBrush*                     IconBrush                                              (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItem::GetIconBrush(struct FSlateBrush* IconBrush, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetIconBrush");

	Params::FortItem_GetIconBrush Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortItem.GetItemDefinitionBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItemDefinition*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItemDefinition* UFortItem::GetItemDefinitionBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetItemDefinitionBP");

	Params::FortItem_GetItemDefinitionBP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetItemGuid
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGuid                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FGuid UFortItem::GetItemGuid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetItemGuid");

	Params::FortItem_GetItemGuid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetLevel");

	Params::FortItem_GetLevel Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetLoadedAmmo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetLoadedAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetLoadedAmmo");

	Params::FortItem_GetLoadedAmmo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetMaxLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetMaxLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetMaxLevel");

	Params::FortItem_GetMaxLevel Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetNormalizedDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortItem::GetNormalizedDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetNormalizedDurability");

	Params::FortItem_GetNormalizedDurability Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetNumInStack
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetNumInStack() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetNumInStack");

	Params::FortItem_GetNumInStack Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetPrimaryCategory
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText*                            ItemCategoryText                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::GetPrimaryCategory(class FText* ItemCategoryText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetPrimaryCategory");

	Params::FortItem_GetPrimaryCategory Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRarity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortRarity                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortRarity UFortItem::GetRarity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRarity");

	Params::FortItem_GetRarity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRarityColor
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UFortItem::GetRarityColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRarityColor");

	Params::FortItem_GetRarityColor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRaritySecondaryColor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UFortItem::GetRaritySecondaryColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRaritySecondaryColor");

	Params::FortItem_GetRaritySecondaryColor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRarityTextShadowColor
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UFortItem::GetRarityTextShadowColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRarityTextShadowColor");

	Params::FortItem_GetRarityTextShadowColor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRecycleValue
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetRecycleValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRecycleValue");

	Params::FortItem_GetRecycleValue Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetRemainingAmmo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetRemainingAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetRemainingAmmo");

	Params::FortItem_GetRemainingAmmo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetSchematicCraftingResultBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortItemDefinition*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortItemDefinition* UFortItem::GetSchematicCraftingResultBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetSchematicCraftingResultBP");

	Params::FortItem_GetSchematicCraftingResultBP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetSchematicResultType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortItemType                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortItemType UFortItem::GetSchematicResultType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetSchematicResultType");

	Params::FortItem_GetSchematicResultType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetSearchTags
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortItem::GetSearchTags() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetSearchTags");

	Params::FortItem_GetSearchTags Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetSecondaryCategory
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText*                            ItemCategoryText                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FSlateBrush*                     ItemCategoryBrush                                      (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::GetSecondaryCategory(class FText* ItemCategoryText, struct FSlateBrush* ItemCategoryBrush, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetSecondaryCategory");

	Params::FortItem_GetSecondaryCategory Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetTertiaryCategory
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText*                            ItemCategoryText                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FSlateBrush*                     ItemCategoryBrush                                      (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::GetTertiaryCategory(class FText* ItemCategoryText, struct FSlateBrush* ItemCategoryBrush, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetTertiaryCategory");

	Params::FortItem_GetTertiaryCategory Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetTier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortItemTier                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortItemTier UFortItem::GetTier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetTier");

	Params::FortItem_GetTier Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortItemType                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortItemType UFortItem::GetType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetType");

	Params::FortItem_GetType Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.GetUpgradeCost
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortItem::GetUpgradeCost() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "GetUpgradeCost");

	Params::FortItem_GetUpgradeCost Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.HasDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::HasDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "HasDurability");

	Params::FortItem_HasDurability Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsActivatable
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsActivatable(class AFortPlayerController* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsActivatable");

	Params::FortItem_IsActivatable Parms{};

	Parms.FortPC = FortPC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsAlterationSlotActive
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsAlterationSlotActive(int32 SlotIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsAlterationSlotActive");

	Params::FortItem_IsAlterationSlotActive Parms{};

	Parms.SlotIndex = SlotIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsEquipable
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AFortPlayerController*      EquippingPC                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsEquipable(const class AFortPlayerController* EquippingPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsEquipable");

	Params::FortItem_IsEquipable Parms{};

	Parms.EquippingPC = EquippingPC;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsEquipped
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsEquipped");

	Params::FortItem_IsEquipped Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsInBackpackOverflow
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsInBackpackOverflow() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsInBackpackOverflow");

	Params::FortItem_IsInBackpackOverflow Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsInStorageVault
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsInStorageVault() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsInStorageVault");

	Params::FortItem_IsInStorageVault Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsSchematic
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsSchematic() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsSchematic");

	Params::FortItem_IsSchematic Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItem.IsSlotted
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItem::IsSlotted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItem", "IsSlotted");

	Params::FortItem_IsSlotted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDialogNotification.CloseTalkingHead
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortDialogNotification::CloseTalkingHead()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDialogNotification", "CloseTalkingHead");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDialogNotification.OnDialogInterrupted
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortDialogNotification::OnDialogInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDialogNotification", "OnDialogInterrupted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortDialogNotification.OpenTalkingHead
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       Image                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      Title                                                  (Parm, NativeAccessSpecifierPublic)

void AFortDialogNotification::OpenTalkingHead(class UTexture2D* Image, const class FText& Title)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDialogNotification", "OpenTalkingHead");

	Params::FortDialogNotification_OpenTalkingHead Parms{};

	Parms.Image = Image;
	Parms.Title = std::move(Title);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAccountItem.HasBeenSeenLocally
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAccountItem::HasBeenSeenLocally() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAccountItem", "HasBeenSeenLocally");

	Params::FortAccountItem_HasBeenSeenLocally Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorker.GetSecondaryCategory
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText*                            ItemCategoryText                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FSlateBrush*                     ItemCategoryBrush                                      (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortWorker::GetSecondaryCategory(class FText* ItemCategoryText, struct FSlateBrush* ItemCategoryBrush, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorker", "GetSecondaryCategory");

	Params::FortWorker_GetSecondaryCategory Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorker.GetTertiaryCategory
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText*                            ItemCategoryText                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FSlateBrush*                     ItemCategoryBrush                                      (Parm, OutParm, NativeAccessSpecifierPublic)
// EFortBrushSize                          BrushSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortWorker::GetTertiaryCategory(class FText* ItemCategoryText, struct FSlateBrush* ItemCategoryBrush, EFortBrushSize BrushSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorker", "GetTertiaryCategory");

	Params::FortWorker_GetTertiaryCategory Parms{};

	Parms.BrushSize = BrushSize;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorker.GetWorkerTypeBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorkerType*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorkerType* UFortWorker::GetWorkerTypeBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorker", "GetWorkerTypeBP");

	Params::FortWorker_GetWorkerTypeBP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHero.GetHeroTypeBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortHeroType*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortHeroType* UFortHero::GetHeroTypeBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHero", "GetHeroTypeBP");

	Params::FortHero_GetHeroTypeBP Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownBuildingDefinitionData.GetBuildingTemplateId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UMyTownBuildingDefinitionData::GetBuildingTemplateId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingDefinitionData", "GetBuildingTemplateId");

	Params::MyTownBuildingDefinitionData_GetBuildingTemplateId Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownBuildingDefinitionData.GetDescription
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FText>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FText> UMyTownBuildingDefinitionData::GetDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingDefinitionData", "GetDescription");

	Params::MyTownBuildingDefinitionData_GetDescription Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.ApplyAlteration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAlterableItem*               Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAlterationItem*              AlterationToApply                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMcpContext::ApplyAlteration(class UFortAlterableItem* Item, class UFortAlterationItem* AlterationToApply)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "ApplyAlteration");

	Params::FortMcpContext_ApplyAlteration Parms{};

	Parms.Item = Item;
	Parms.AlterationToApply = AlterationToApply;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.CancelEpicPurchasingDisplay
// (Final, Native, Public, BlueprintCallable)

void UFortMcpContext::CancelEpicPurchasingDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "CancelEpicPurchasingDisplay");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.ListMtxPackages
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(const TArray<struct FMtxPackage>& Offers)>&Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortMcpContext::ListMtxPackages(const TDelegate<void(const TArray<struct FMtxPackage>& Offers)>& Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "ListMtxPackages");

	Params::FortMcpContext_ListMtxPackages Parms{};

	Parms.Callback = Callback;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.MarkItemSeen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortAccountItem*           ItemToMarkSeen                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMcpContext::MarkItemSeen(const class UFortAccountItem* ItemToMarkSeen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "MarkItemSeen");

	Params::FortMcpContext_MarkItemSeen Parms{};

	Parms.ItemToMarkSeen = ItemToMarkSeen;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.PurchaseRealMoneyCatalogEntry
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    OfferId                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(bool bSuccess)>&   Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortMcpContext::PurchaseRealMoneyCatalogEntry(const class FString& OfferId, const TDelegate<void(bool bSuccess)>& Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "PurchaseRealMoneyCatalogEntry");

	Params::FortMcpContext_PurchaseRealMoneyCatalogEntry Parms{};

	Parms.OfferId = std::move(OfferId);
	Parms.Callback = Callback;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.RecycleItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItem*                  ItemToRecycle                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMcpContext::RecycleItem(const class UFortItem* ItemToRecycle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "RecycleItem");

	Params::FortMcpContext_RecycleItem Parms{};

	Parms.ItemToRecycle = ItemToRecycle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.RegisterForEpicPurchasingDisplay
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TDelegate<void(class UWidget* WebWidget, const class FString& OfferId)>&DisplayCallback                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void()>&                DismissCallback                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UFortMcpContext::RegisterForEpicPurchasingDisplay(const TDelegate<void(class UWidget* WebWidget, const class FString& OfferId)>& DisplayCallback, const TDelegate<void()>& DismissCallback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "RegisterForEpicPurchasingDisplay");

	Params::FortMcpContext_RegisterForEpicPurchasingDisplay Parms{};

	Parms.DisplayCallback = DisplayCallback;
	Parms.DismissCallback = DismissCallback;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.UpgradeItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItem*                  ItemToUpgrade                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMcpContext::UpgradeItem(const class UFortItem* ItemToUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "UpgradeItem");

	Params::FortMcpContext_UpgradeItem Parms{};

	Parms.ItemToUpgrade = ItemToUpgrade;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMcpContext.GetAccountItemWithDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortAccountItemDefinition* AccountItemDefinition                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAccountItem*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAccountItem* UFortMcpContext::GetAccountItemWithDefinition(const class UFortAccountItemDefinition* AccountItemDefinition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetAccountItemWithDefinition");

	Params::FortMcpContext_GetAccountItemWithDefinition Parms{};

	Parms.AccountItemDefinition = AccountItemDefinition;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.GetAllAlterations
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAlterationItem*>*     OutAlterations                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// EFortAlteration                         InAlterationType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMcpContext::GetAllAlterations(TArray<class UFortAlterationItem*>* OutAlterations, EFortAlteration InAlterationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetAllAlterations");

	Params::FortMcpContext_GetAllAlterations Parms{};

	Parms.InAlterationType = InAlterationType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortMcpContext.GetAllHeroes
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortHero*>*               Result                                                 (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortMcpContext::GetAllHeroes(TArray<class UFortHero*>* Result) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetAllHeroes");

	Params::FortMcpContext_GetAllHeroes Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortMcpContext.GetCurrentlyViewedAccountInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortPublicAccountInfo*          Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)

void UFortMcpContext::GetCurrentlyViewedAccountInfo(struct FFortPublicAccountInfo* Result) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetCurrentlyViewedAccountInfo");

	Params::FortMcpContext_GetCurrentlyViewedAccountInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortMcpContext.GetDefaultHero
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortHero*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortHero* UFortMcpContext::GetDefaultHero() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetDefaultHero");

	Params::FortMcpContext_GetDefaultHero Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.GetHomeBaseInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortHomeBaseInfo*               Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)

void UFortMcpContext::GetHomeBaseInfo(struct FFortHomeBaseInfo* Result) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetHomeBaseInfo");

	Params::FortMcpContext_GetHomeBaseInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortMcpContext.GetHomeBaseInfoForPlayer
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortHomeBaseInfo*               Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// const struct FUniqueNetIdRepl&          MemberUniqueId                                         (Parm, NativeAccessSpecifierPublic)

void UFortMcpContext::GetHomeBaseInfoForPlayer(struct FFortHomeBaseInfo* Result, const struct FUniqueNetIdRepl& MemberUniqueId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetHomeBaseInfoForPlayer");

	Params::FortMcpContext_GetHomeBaseInfoForPlayer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function FortniteGame.FortMcpContext.GetLocalAccountInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortPrivateAccountInfo*         Result                                                 (Parm, OutParm, NativeAccessSpecifierPublic)

void UFortMcpContext::GetLocalAccountInfo(struct FFortPrivateAccountInfo* Result) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetLocalAccountInfo");

	Params::FortMcpContext_GetLocalAccountInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Result != nullptr)
		*Result = std::move(Parms.Result);
}


// Function FortniteGame.FortMcpContext.GetPersonnelXpBalance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortMcpContext::GetPersonnelXpBalance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetPersonnelXpBalance");

	Params::FortMcpContext_GetPersonnelXpBalance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.GetSchematicXpBalance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortMcpContext::GetSchematicXpBalance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "GetSchematicXpBalance");

	Params::FortMcpContext_GetSchematicXpBalance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.IsDailyRewardAvailable
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float*                                  OutSecondsUntilNextReward                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutRewardAvailable                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMcpContext::IsDailyRewardAvailable(float* OutSecondsUntilNextReward, bool* OutRewardAvailable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "IsDailyRewardAvailable");

	Params::FortMcpContext_IsDailyRewardAvailable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSecondsUntilNextReward != nullptr)
		*OutSecondsUntilNextReward = Parms.OutSecondsUntilNextReward;

	if (OutRewardAvailable != nullptr)
		*OutRewardAvailable = Parms.OutRewardAvailable;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpContext.IsLocalPlayersUniqueID
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMcpContext::IsLocalPlayersUniqueID(const struct FUniqueNetIdRepl& PlayerID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpContext", "IsLocalPlayersUniqueID");

	Params::FortMcpContext_IsLocalPlayersUniqueID Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.DepositPOSTResource
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortItemDefinition*        ResourceItem                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOutpostContext::DepositPOSTResource(const class UFortItemDefinition* ResourceItem, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "DepositPOSTResource");

	Params::FortOutpostContext_DepositPOSTResource Parms{};

	Parms.ResourceItem = ResourceItem;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostContext.IncreaseOutpostPrestigeLevel
// (Final, Native, Public, BlueprintCallable)

void UFortOutpostContext::IncreaseOutpostPrestigeLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "IncreaseOutpostPrestigeLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostContext.UpgradePOST
// (Final, Native, Public, BlueprintCallable)

void UFortOutpostContext::UpgradePOST()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "UpgradePOST");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostContext.UpgradeStructure
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortOutpostItemDefinition*       StructureToUpgrade                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOutpostContext::UpgradeStructure(class UFortOutpostItemDefinition* StructureToUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "UpgradeStructure");

	Params::FortOutpostContext_UpgradeStructure Parms{};

	Parms.StructureToUpgrade = StructureToUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostContext.CanUpgradePOST
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortOutpostContext::CanUpgradePOST() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "CanUpgradePOST");

	Params::FortOutpostContext_CanUpgradePOST Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.CanUpgradeStructure
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLog                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortOutpostContext::CanUpgradeStructure(class UFortOutpostItemDefinition* OutpostStructure, bool bLog) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "CanUpgradeStructure");

	Params::FortOutpostContext_CanUpgradeStructure Parms{};

	Parms.OutpostStructure = OutpostStructure;
	Parms.bLog = bLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetHarvestingToolForLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   InHarvestingOptimizerLevel                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorldItemDefinition* UFortOutpostContext::GetHarvestingToolForLevel(int32 InHarvestingOptimizerLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetHarvestingToolForLevel");

	Params::FortOutpostContext_GetHarvestingToolForLevel Parms{};

	Parms.InHarvestingOptimizerLevel = InHarvestingOptimizerLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetNextPOSTLevelRequirements
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UOutpostPOSTRequirementData*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UOutpostPOSTRequirementData*> UFortOutpostContext::GetNextPOSTLevelRequirements() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetNextPOSTLevelRequirements");

	Params::FortOutpostContext_GetNextPOSTLevelRequirements Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetOutpostPrestigeLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortOutpostContext::GetOutpostPrestigeLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetOutpostPrestigeLevel");

	Params::FortOutpostContext_GetOutpostPrestigeLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetOutpostStructure
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AOutpostStructureBase*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AOutpostStructureBase* UFortOutpostContext::GetOutpostStructure(class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetOutpostStructure");

	Params::FortOutpostContext_GetOutpostStructure Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetPOSTBuildingHealthMod
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   POSTLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortOutpostContext::GetPOSTBuildingHealthMod(int32 POSTLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetPOSTBuildingHealthMod");

	Params::FortOutpostContext_GetPOSTBuildingHealthMod Parms{};

	Parms.POSTLevel = POSTLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetStormShieldLevelDefended
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortOutpostContext::GetStormShieldLevelDefended() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetStormShieldLevelDefended");

	Params::FortOutpostContext_GetStormShieldLevelDefended Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetStructureLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortOutpostContext::GetStructureLevel(class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetStructureLevel");

	Params::FortOutpostContext_GetStructureLevel Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetStructureMaxLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortOutpostContext::GetStructureMaxLevel(class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetStructureMaxLevel");

	Params::FortOutpostContext_GetStructureMaxLevel Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.GetUpgradeStructureCost
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutWorldItems                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutAccountItems                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortOutpostContext::GetUpgradeStructureCost(class UFortOutpostItemDefinition* OutpostStructure, TArray<struct FFortItemQuantityPair>* OutWorldItems, TArray<struct FFortItemQuantityPair>* OutAccountItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "GetUpgradeStructureCost");

	Params::FortOutpostContext_GetUpgradeStructureCost Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldItems != nullptr)
		*OutWorldItems = std::move(Parms.OutWorldItems);

	if (OutAccountItems != nullptr)
		*OutAccountItems = std::move(Parms.OutAccountItems);
}


// Function FortniteGame.FortOutpostContext.IsPrestigeAllowed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortOutpostContext::IsPrestigeAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "IsPrestigeAllowed");

	Params::FortOutpostContext_IsPrestigeAllowed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostContext.LeaveOutpostAsParty
// (Final, Native, Public, BlueprintCallable, Const)

void UFortOutpostContext::LeaveOutpostAsParty() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostContext", "LeaveOutpostAsParty");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUITeamInfo.GetTeamHitPointFractions
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<float>*                          HealthFractions                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<float>*                          ShieldFractions                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortUITeamInfo::GetTeamHitPointFractions(TArray<float>* HealthFractions, TArray<float>* ShieldFractions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUITeamInfo", "GetTeamHitPointFractions");

	Params::FortUITeamInfo_GetTeamHitPointFractions Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (HealthFractions != nullptr)
		*HealthFractions = std::move(Parms.HealthFractions);

	if (ShieldFractions != nullptr)
		*ShieldFractions = std::move(Parms.ShieldFractions);
}


// Function FortniteGame.FortUITeamInfo.GetTeamMemberIDs
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FUniqueNetIdRepl>*        TeamMemberIDs                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortUITeamInfo::GetTeamMemberIDs(TArray<struct FUniqueNetIdRepl>* TeamMemberIDs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUITeamInfo", "GetTeamMemberIDs");

	Params::FortUITeamInfo_GetTeamMemberIDs Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (TeamMemberIDs != nullptr)
		*TeamMemberIDs = std::move(Parms.TeamMemberIDs);
}


// Function FortniteGame.FortUITeamInfo.GetTeamMembers
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortTeamMemberInfo>*     TeamMembers                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortUITeamInfo::GetTeamMembers(TArray<struct FFortTeamMemberInfo>* TeamMembers)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUITeamInfo", "GetTeamMembers");

	Params::FortUITeamInfo_GetTeamMembers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (TeamMembers != nullptr)
		*TeamMembers = std::move(Parms.TeamMembers);
}


// Function FortniteGame.FortPartyContext.IsValidNetID
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          UniqueNetID                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsValidNetID(const struct FUniqueNetIdRepl& UniqueNetID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPartyContext", "IsValidNetID");

	Params::FortPartyContext_IsValidNetID Parms{};

	Parms.UniqueNetID = std::move(UniqueNetID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.AcceptFriendRequest
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::AcceptFriendRequest(const struct FUniqueNetIdRepl& PlayerID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "AcceptFriendRequest");

	Params::FortPartyContext_AcceptFriendRequest Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.CancelFriendRequest
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::CancelFriendRequest(const struct FUniqueNetIdRepl& PlayerID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "CancelFriendRequest");

	Params::FortPartyContext_CancelFriendRequest Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.ClearPendingInvites
// (Final, Native, Public, BlueprintCallable)

void UFortPartyContext::ClearPendingInvites()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "ClearPendingInvites");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.GetActiveFriendsList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class UFortSocialItem*>*         OutActiveFriends                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortPartyContext::GetActiveFriendsList(TArray<class UFortSocialItem*>* OutActiveFriends)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetActiveFriendsList");

	Params::FortPartyContext_GetActiveFriendsList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActiveFriends != nullptr)
		*OutActiveFriends = std::move(Parms.OutActiveFriends);
}


// Function FortniteGame.FortPartyContext.GetPartyInvites
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class UFortSocialItem*>*         OutPartyInvites                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortPartyContext::GetPartyInvites(TArray<class UFortSocialItem*>* OutPartyInvites)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetPartyInvites");

	Params::FortPartyContext_GetPartyInvites Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPartyInvites != nullptr)
		*OutPartyInvites = std::move(Parms.OutPartyInvites);
}


// Function FortniteGame.FortPartyContext.GetPartyPrivacySetting
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EPartyType*                             OutPartyType                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutLeaderFriendsOnly                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   OutLeaderInvitesOnly                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::GetPartyPrivacySetting(EPartyType* OutPartyType, bool* OutLeaderFriendsOnly, bool* OutLeaderInvitesOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetPartyPrivacySetting");

	Params::FortPartyContext_GetPartyPrivacySetting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPartyType != nullptr)
		*OutPartyType = Parms.OutPartyType;

	if (OutLeaderFriendsOnly != nullptr)
		*OutLeaderFriendsOnly = Parms.OutLeaderFriendsOnly;

	if (OutLeaderInvitesOnly != nullptr)
		*OutLeaderInvitesOnly = Parms.OutLeaderInvitesOnly;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetSocialItemList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class UFortSocialItem*>*         OutSocialItems                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortPartyContext::GetSocialItemList(TArray<class UFortSocialItem*>* OutSocialItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetSocialItemList");

	Params::FortPartyContext_GetSocialItemList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSocialItems != nullptr)
		*OutSocialItems = std::move(Parms.OutSocialItems);
}


// Function FortniteGame.FortPartyContext.GetTeamInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortUITeamInfo*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUITeamInfo* UFortPartyContext::GetTeamInfo(EFortTeam Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetTeamInfo");

	Params::FortPartyContext_GetTeamInfo Parms{};

	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.HandlePendingInvites
// (Final, Native, Public, BlueprintCallable)

void UFortPartyContext::HandlePendingInvites()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "HandlePendingInvites");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.JoinParty
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortSocialItem*                  PartyItem                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPartyContext::JoinParty(class UFortSocialItem* PartyItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "JoinParty");

	Params::FortPartyContext_JoinParty Parms{};

	Parms.PartyItem = PartyItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.KickPartyMember
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PartyMemberId                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::KickPartyMember(const struct FUniqueNetIdRepl& PartyMemberId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "KickPartyMember");

	Params::FortPartyContext_KickPartyMember Parms{};

	Parms.PartyMemberId = std::move(PartyMemberId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.LeaveParty
// (Final, Native, Public, BlueprintCallable)

void UFortPartyContext::LeaveParty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "LeaveParty");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.PromotePartyMemberToLeader
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PartyMemberId                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::PromotePartyMemberToLeader(const struct FUniqueNetIdRepl& PartyMemberId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "PromotePartyMemberToLeader");

	Params::FortPartyContext_PromotePartyMemberToLeader Parms{};

	Parms.PartyMemberId = std::move(PartyMemberId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.RejectFriendRequest
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::RejectFriendRequest(const struct FUniqueNetIdRepl& PlayerID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "RejectFriendRequest");

	Params::FortPartyContext_RejectFriendRequest Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.RejectPartyInvite
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortSocialItem*                  PartyInvite                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPartyContext::RejectPartyInvite(class UFortSocialItem* PartyInvite)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "RejectPartyInvite");

	Params::FortPartyContext_RejectPartyInvite Parms{};

	Parms.PartyInvite = PartyInvite;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.SendFriendRequest
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::SendFriendRequest(const struct FUniqueNetIdRepl& PlayerID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "SendFriendRequest");

	Params::FortPartyContext_SendFriendRequest Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.SendPartyInvite
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortSocialItem*                  SocialItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPartyContext::SendPartyInvite(class UFortSocialItem* SocialItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "SendPartyInvite");

	Params::FortPartyContext_SendPartyInvite Parms{};

	Parms.SocialItem = SocialItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.SetChatWhisperTarget
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FUniqueNetIdRepl&          FriendID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortPartyContext::SetChatWhisperTarget(const struct FUniqueNetIdRepl& FriendID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "SetChatWhisperTarget");

	Params::FortPartyContext_SetChatWhisperTarget Parms{};

	Parms.FriendID = std::move(FriendID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.SetPartyPrivacySetting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPartyType                              PartyType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLeaderFriendsOnly                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bLeaderInvitesOnly                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortPartyContext::SetPartyPrivacySetting(EPartyType PartyType, bool bLeaderFriendsOnly, bool bLeaderInvitesOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "SetPartyPrivacySetting");

	Params::FortPartyContext_SetPartyPrivacySetting Parms{};

	Parms.PartyType = PartyType;
	Parms.bLeaderFriendsOnly = bLeaderFriendsOnly;
	Parms.bLeaderInvitesOnly = bLeaderInvitesOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyContext.CanBeInvited
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSocialItem*                  SocialItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortPartyRestriction*                  FailReason                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::CanBeInvited(class UFortSocialItem* SocialItem, EFortPartyRestriction* FailReason) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "CanBeInvited");

	Params::FortPartyContext_CanBeInvited Parms{};

	Parms.SocialItem = SocialItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FailReason != nullptr)
		*FailReason = Parms.FailReason;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.CanBeJoined
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSocialItem*                  SocialItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortPartyRestriction*                  FailReason                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::CanBeJoined(class UFortSocialItem* SocialItem, EFortPartyRestriction* FailReason) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "CanBeJoined");

	Params::FortPartyContext_CanBeJoined Parms{};

	Parms.SocialItem = SocialItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FailReason != nullptr)
		*FailReason = Parms.FailReason;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetFriendRequestStatusForPlayer
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EFortFriendRequestStatus                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortFriendRequestStatus UFortPartyContext::GetFriendRequestStatusForPlayer(const struct FUniqueNetIdRepl& PlayerID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetFriendRequestStatusForPlayer");

	Params::FortPartyContext_GetFriendRequestStatusForPlayer Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetLocalPartyMemberIDs
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FUniqueNetIdRepl>*        PartyMemberIDs                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bIncludeLocalPlayerID                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortPartyContext::GetLocalPartyMemberIDs(TArray<struct FUniqueNetIdRepl>* PartyMemberIDs, bool bIncludeLocalPlayerID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetLocalPartyMemberIDs");

	Params::FortPartyContext_GetLocalPartyMemberIDs Parms{};

	Parms.bIncludeLocalPlayerID = bIncludeLocalPlayerID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PartyMemberIDs != nullptr)
		*PartyMemberIDs = std::move(Parms.PartyMemberIDs);
}


// Function FortniteGame.FortPartyContext.GetLocalPartyProgression
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortPartyState                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortPartyState UFortPartyContext::GetLocalPartyProgression() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetLocalPartyProgression");

	Params::FortPartyContext_GetLocalPartyProgression Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetLocalPlayerDisplayName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UFortPartyContext::GetLocalPlayerDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetLocalPlayerDisplayName");

	Params::FortPartyContext_GetLocalPlayerDisplayName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetLocalPlayerTeam
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortUITeamInfo*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortUITeamInfo* UFortPartyContext::GetLocalPlayerTeam() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetLocalPlayerTeam");

	Params::FortPartyContext_GetLocalPlayerTeam Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetLocalPlayerTeamMemberInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortTeamMemberInfo*             LocalPlayerInfo                                        (Parm, OutParm, NativeAccessSpecifierPublic)

void UFortPartyContext::GetLocalPlayerTeamMemberInfo(struct FFortTeamMemberInfo* LocalPlayerInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetLocalPlayerTeamMemberInfo");

	Params::FortPartyContext_GetLocalPlayerTeamMemberInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LocalPlayerInfo != nullptr)
		*LocalPlayerInfo = std::move(Parms.LocalPlayerInfo);
}


// Function FortniteGame.FortPartyContext.GetMaxTeamSizeForSelectedTheater
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortPartyContext::GetMaxTeamSizeForSelectedTheater() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetMaxTeamSizeForSelectedTheater");

	Params::FortPartyContext_GetMaxTeamSizeForSelectedTheater Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.GetNumPlayersInLocalParty
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortPartyContext::GetNumPlayersInLocalParty() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "GetNumPlayersInLocalParty");

	Params::FortPartyContext_GetNumPlayersInLocalParty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.HasPendingFriendRequest
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::HasPendingFriendRequest() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "HasPendingFriendRequest");

	Params::FortPartyContext_HasPendingFriendRequest Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsActiveFriend
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsActiveFriend(const struct FUniqueNetIdRepl& PlayerID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsActiveFriend");

	Params::FortPartyContext_IsActiveFriend Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsActiveFriendsListRetrieved
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsActiveFriendsListRetrieved() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsActiveFriendsListRetrieved");

	Params::FortPartyContext_IsActiveFriendsListRetrieved Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsEntirePartyInFrontEnd
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsEntirePartyInFrontEnd() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsEntirePartyInFrontEnd");

	Params::FortPartyContext_IsEntirePartyInFrontEnd Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsInLocalPlayersParty
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FUniqueNetIdRepl&          PlayerID                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsInLocalPlayersParty(const struct FUniqueNetIdRepl& PlayerID) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsInLocalPlayersParty");

	Params::FortPartyContext_IsInLocalPlayersParty Parms{};

	Parms.PlayerID = std::move(PlayerID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsLocalPlayerInParty
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortSocialItem*                  SocialItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsLocalPlayerInParty(class UFortSocialItem* SocialItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsLocalPlayerInParty");

	Params::FortPartyContext_IsLocalPlayerInParty Parms{};

	Parms.SocialItem = SocialItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.IsLocalPlayerPartyLeader
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::IsLocalPlayerPartyLeader() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "IsLocalPlayerPartyLeader");

	Params::FortPartyContext_IsLocalPlayerPartyLeader Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPartyContext.ShouldShowHeroPortraits
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPartyContext::ShouldShowHeroPortraits() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyContext", "ShouldShowHeroPortraits");

	Params::FortPartyContext_ShouldShowHeroPortraits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTutorialContext.ClearTutorialHighlights
// (Final, Native, Public, BlueprintCallable)

void UFortTutorialContext::ClearTutorialHighlights()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "ClearTutorialHighlights");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.DisableTutorialHighlight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::DisableTutorialHighlight(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "DisableTutorialHighlight");

	Params::FortTutorialContext_DisableTutorialHighlight Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.DisableTutorialHighlightForBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           BangType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::DisableTutorialHighlightForBang(EFortBangType BangType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "DisableTutorialHighlightForBang");

	Params::FortTutorialContext_DisableTutorialHighlightForBang Parms{};

	Parms.BangType = BangType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.EnableTutorialHighlight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::EnableTutorialHighlight(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "EnableTutorialHighlight");

	Params::FortTutorialContext_EnableTutorialHighlight Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.EnableTutorialHighlightForBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           BangType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::EnableTutorialHighlightForBang(EFortBangType BangType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "EnableTutorialHighlightForBang");

	Params::FortTutorialContext_EnableTutorialHighlightForBang Parms{};

	Parms.BangType = BangType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.HideTutorialWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::HideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "HideTutorialWidget");

	Params::FortTutorialContext_HideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.HideTutorialWidgetForBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           BangType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::HideTutorialWidgetForBang(EFortBangType BangType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "HideTutorialWidgetForBang");

	Params::FortTutorialContext_HideTutorialWidgetForBang Parms{};

	Parms.BangType = BangType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.SetTutorialNotificationActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortTutorialContext::SetTutorialNotificationActive(bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "SetTutorialNotificationActive");

	Params::FortTutorialContext_SetTutorialNotificationActive Parms{};

	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.SkipTutorial
// (Final, Native, Public, BlueprintCallable)

void UFortTutorialContext::SkipTutorial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "SkipTutorial");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.UnhideAllTutorialWidgets
// (Final, Native, Public, BlueprintCallable)

void UFortTutorialContext::UnhideAllTutorialWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "UnhideAllTutorialWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.UnhideTutorialWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::UnhideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "UnhideTutorialWidget");

	Params::FortTutorialContext_UnhideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.UnhideTutorialWidgetForBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortBangType                           BangType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortTutorialContext::UnhideTutorialWidgetForBang(EFortBangType BangType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "UnhideTutorialWidgetForBang");

	Params::FortTutorialContext_UnhideTutorialWidgetForBang Parms{};

	Parms.BangType = BangType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialContext.ShouldPromptToSkipTutorial
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTutorialContext::ShouldPromptToSkipTutorial() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialContext", "ShouldPromptToSkipTutorial");

	Params::FortTutorialContext_ShouldPromptToSkipTutorial Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestObjectiveInfo.GetObjectiveStatRow
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FFortQuestObjectiveStatTableRow* OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestObjectiveInfo::GetObjectiveStatRow(struct FFortQuestObjectiveStatTableRow* OutRow) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestObjectiveInfo", "GetObjectiveStatRow");

	Params::FortQuestObjectiveInfo_GetObjectiveStatRow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestObjectiveInfo.GetOwningQuest
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortQuestItem*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestItem* UFortQuestObjectiveInfo::GetOwningQuest() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestObjectiveInfo", "GetOwningQuest");

	Params::FortQuestObjectiveInfo_GetOwningQuest Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.GetMissionConfigData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              InBucketTag                                            (Parm, NativeAccessSpecifierPublic)
// class UFortMissionConfigData*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortMissionConfigData* UFortQuestItem::GetMissionConfigData(const struct FGameplayTag& InBucketTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetMissionConfigData");

	Params::FortQuestItem_GetMissionConfigData Parms{};

	Parms.InBucketTag = std::move(InBucketTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.GetAchievedCount
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32*                                  OutTotalAchievedCount                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutTotalRequiredCount                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortQuestItem::GetAchievedCount(int32* OutTotalAchievedCount, int32* OutTotalRequiredCount) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetAchievedCount");

	Params::FortQuestItem_GetAchievedCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTotalAchievedCount != nullptr)
		*OutTotalAchievedCount = Parms.OutTotalAchievedCount;

	if (OutTotalRequiredCount != nullptr)
		*OutTotalRequiredCount = Parms.OutTotalRequiredCount;
}


// Function FortniteGame.FortQuestItem.GetObjectiveInfo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FDataTableRowHandle&       ObjectiveStatHandle                                    (Parm, NativeAccessSpecifierPublic)
// class UFortQuestObjectiveInfo*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestObjectiveInfo* UFortQuestItem::GetObjectiveInfo(const struct FDataTableRowHandle& ObjectiveStatHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetObjectiveInfo");

	Params::FortQuestItem_GetObjectiveInfo Parms{};

	Parms.ObjectiveStatHandle = std::move(ObjectiveStatHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.GetPercentageComplete
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortQuestItem::GetPercentageComplete() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetPercentageComplete");

	Params::FortQuestItem_GetPercentageComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.GetPreviewRewards
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FFortQuestReward>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FFortQuestReward> UFortQuestItem::GetPreviewRewards() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetPreviewRewards");

	Params::FortQuestItem_GetPreviewRewards Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.GetQuestDefinitionBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortQuestItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestItemDefinition* UFortQuestItem::GetQuestDefinitionBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "GetQuestDefinitionBP");

	Params::FortQuestItem_GetQuestDefinitionBP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.HasCompletedObjective
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FDataTableRowHandle&       ObjectiveStatHandle                                    (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestItem::HasCompletedObjective(const struct FDataTableRowHandle& ObjectiveStatHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "HasCompletedObjective");

	Params::FortQuestItem_HasCompletedObjective Parms{};

	Parms.ObjectiveStatHandle = std::move(ObjectiveStatHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.HasCompletedQuest
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestItem::HasCompletedQuest() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "HasCompletedQuest");

	Params::FortQuestItem_HasCompletedQuest Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestItem.IsVisibleToUser
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestItem::IsVisibleToUser() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestItem", "IsVisibleToUser");

	Params::FortQuestItem_IsVisibleToUser Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpProfileAccount.ApplyAlteration
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TargetItemId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    AlterationItemId                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::ApplyAlteration(const class FString& TargetItemId, const class FString& AlterationItemId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "ApplyAlteration");

	Params::FortMcpProfileAccount_ApplyAlteration Parms{};

	Parms.TargetItemId = std::move(TargetItemId);
	Parms.AlterationItemId = std::move(AlterationItemId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.AssignWorkerToBuilding
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    WorkerId                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::AssignWorkerToBuilding(const class FString& WorkerId, const class FString& BuildingId, int32 SlotIndex, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "AssignWorkerToBuilding");

	Params::FortMcpProfileAccount_AssignWorkerToBuilding Parms{};

	Parms.WorkerId = std::move(WorkerId);
	Parms.BuildingId = std::move(BuildingId);
	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.AssignWorkerToBuildingBatch
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            WorkerIds                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class FString>&            BuildingIds                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    SlotIndices                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::AssignWorkerToBuildingBatch(const TArray<class FString>& WorkerIds, const TArray<class FString>& BuildingIds, const TArray<int32>& SlotIndices, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "AssignWorkerToBuildingBatch");

	Params::FortMcpProfileAccount_AssignWorkerToBuildingBatch Parms{};

	Parms.WorkerIds = std::move(WorkerIds);
	Parms.BuildingIds = std::move(BuildingIds);
	Parms.SlotIndices = std::move(SlotIndices);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.ClaimLoginReward
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::ClaimLoginReward(struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "ClaimLoginReward");

	Params::FortMcpProfileAccount_ClaimLoginReward Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.ClaimQuestReward
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    QuestId                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::ClaimQuestReward(const class FString& QuestId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "ClaimQuestReward");

	Params::FortMcpProfileAccount_ClaimQuestReward Parms{};

	Parms.QuestId = std::move(QuestId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.ConsumeItems
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            ItemsToConsumeIds                                      (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    ItemCountsToConsume                                    (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    ConsumeReason                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::ConsumeItems(const TArray<class FString>& ItemsToConsumeIds, const TArray<int32>& ItemCountsToConsume, const class FString& ConsumeReason, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "ConsumeItems");

	Params::FortMcpProfileAccount_ConsumeItems Parms{};

	Parms.ItemsToConsumeIds = std::move(ItemsToConsumeIds);
	Parms.ItemCountsToConsume = std::move(ItemCountsToConsume);
	Parms.ConsumeReason = std::move(ConsumeReason);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.CreateBuilding
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TemplateId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::CreateBuilding(const class FString& TemplateId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "CreateBuilding");

	Params::FortMcpProfileAccount_CreateBuilding Parms{};

	Parms.TemplateId = std::move(TemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.CreateHero
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    HeroName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Gender                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    HeroTemplateId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::CreateHero(const class FString& HeroName, int32 Gender, const class FString& HeroTemplateId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "CreateHero");

	Params::FortMcpProfileAccount_CreateHero Parms{};

	Parms.HeroName = std::move(HeroName);
	Parms.Gender = Gender;
	Parms.HeroTemplateId = std::move(HeroTemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.DeleteHero
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::DeleteHero(const class FString& HeroId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "DeleteHero");

	Params::FortMcpProfileAccount_DeleteHero Parms{};

	Parms.HeroId = std::move(HeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.EarnScore
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// int32                                   TotalScore                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MatchmakingSessionId                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCriticalMatchBonus                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::EarnScore(int32 TotalScore, const class FString& MatchmakingSessionId, const class FString& HeroId, bool bCriticalMatchBonus, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "EarnScore");

	Params::FortMcpProfileAccount_EarnScore Parms{};

	Parms.TotalScore = TotalScore;
	Parms.MatchmakingSessionId = std::move(MatchmakingSessionId);
	Parms.HeroId = std::move(HeroId);
	Parms.bCriticalMatchBonus = bCriticalMatchBonus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.EndPrimaryMission
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    MatchmakingSessionId                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MissionName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MissionStatus                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumMissionPoints                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCriticalMatchBonus                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::EndPrimaryMission(const class FString& MatchmakingSessionId, const class FString& MissionName, const class FString& MissionStatus, int32 NumMissionPoints, bool bCriticalMatchBonus, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "EndPrimaryMission");

	Params::FortMcpProfileAccount_EndPrimaryMission Parms{};

	Parms.MatchmakingSessionId = std::move(MatchmakingSessionId);
	Parms.MissionName = std::move(MissionName);
	Parms.MissionStatus = std::move(MissionStatus);
	Parms.NumMissionPoints = NumMissionPoints;
	Parms.bCriticalMatchBonus = bCriticalMatchBonus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.EquipCharCosmetic
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    CharacterId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CosmeticId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TypeId                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::EquipCharCosmetic(const class FString& CharacterId, const class FString& CosmeticId, int32 TypeId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "EquipCharCosmetic");

	Params::FortMcpProfileAccount_EquipCharCosmetic Parms{};

	Parms.CharacterId = std::move(CharacterId);
	Parms.CosmeticId = std::move(CosmeticId);
	Parms.TypeId = TypeId;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.FortRerollDailyQuest
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    QuestId                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::FortRerollDailyQuest(const class FString& QuestId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "FortRerollDailyQuest");

	Params::FortMcpProfileAccount_FortRerollDailyQuest Parms{};

	Parms.QuestId = std::move(QuestId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.MarkItemSeen
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            ItemIds                                                (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::MarkItemSeen(const TArray<class FString>& ItemIds, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "MarkItemSeen");

	Params::FortMcpProfileAccount_MarkItemSeen Parms{};

	Parms.ItemIds = std::move(ItemIds);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.MarkNewQuestNotificationSent
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            ItemIds                                                (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::MarkNewQuestNotificationSent(const TArray<class FString>& ItemIds, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "MarkNewQuestNotificationSent");

	Params::FortMcpProfileAccount_MarkNewQuestNotificationSent Parms{};

	Parms.ItemIds = std::move(ItemIds);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.OpenCardPack
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    CardPackItemId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SelectionIdx                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::OpenCardPack(const class FString& CardPackItemId, int32 SelectionIdx, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "OpenCardPack");

	Params::FortMcpProfileAccount_OpenCardPack Parms{};

	Parms.CardPackItemId = std::move(CardPackItemId);
	Parms.SelectionIdx = SelectionIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.QuestLogin
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::QuestLogin(struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "QuestLogin");

	Params::FortMcpProfileAccount_QuestLogin Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.RecycleItem
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TargetItemId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::RecycleItem(const class FString& TargetItemId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "RecycleItem");

	Params::FortMcpProfileAccount_RecycleItem Parms{};

	Parms.TargetItemId = std::move(TargetItemId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.RenameHero
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NewHeroName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::RenameHero(const class FString& HeroId, const class FString& NewHeroName, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "RenameHero");

	Params::FortMcpProfileAccount_RenameHero Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.NewHeroName = std::move(NewHeroName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetDefaultHero
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    DefaultHeroId                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetDefaultHero(const class FString& DefaultHeroId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetDefaultHero");

	Params::FortMcpProfileAccount_SetDefaultHero Parms{};

	Parms.DefaultHeroId = std::move(DefaultHeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetGameplayStats
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<struct FFortPersistentGameplayStatValue>&GameplayStats                                          (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetGameplayStats(const TArray<struct FFortPersistentGameplayStatValue>& GameplayStats, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetGameplayStats");

	Params::FortMcpProfileAccount_SetGameplayStats Parms{};

	Parms.GameplayStats = std::move(GameplayStats);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetHeroAbilities
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   PrimaryTraitAbilities                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SecondaryTraitAbilities_Alpha                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SecondaryTraitAbilities_Beta                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SecondaryTraitAbilities_Gamma                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SecondaryTraitAbilities_Delta                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetHeroAbilities(const class FString& HeroId, int32 PrimaryTraitAbilities, int32 SecondaryTraitAbilities_Alpha, int32 SecondaryTraitAbilities_Beta, int32 SecondaryTraitAbilities_Gamma, int32 SecondaryTraitAbilities_Delta, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetHeroAbilities");

	Params::FortMcpProfileAccount_SetHeroAbilities Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.PrimaryTraitAbilities = PrimaryTraitAbilities;
	Parms.SecondaryTraitAbilities_Alpha = SecondaryTraitAbilities_Alpha;
	Parms.SecondaryTraitAbilities_Beta = SecondaryTraitAbilities_Beta;
	Parms.SecondaryTraitAbilities_Gamma = SecondaryTraitAbilities_Gamma;
	Parms.SecondaryTraitAbilities_Delta = SecondaryTraitAbilities_Delta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetHeroModeLoadout
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortSavedModeLoadout&     ModeLoadout                                            (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetHeroModeLoadout(const class FString& HeroId, const struct FFortSavedModeLoadout& ModeLoadout, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetHeroModeLoadout");

	Params::FortMcpProfileAccount_SetHeroModeLoadout Parms{};

	Parms.HeroId = std::move(HeroId);
	Parms.ModeLoadout = std::move(ModeLoadout);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetHomebaseMeta
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TownName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   FlagPattern                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FlagColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetHomebaseMeta(const class FString& TownName, int32 FlagPattern, float FlagColor, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetHomebaseMeta");

	Params::FortMcpProfileAccount_SetHomebaseMeta Parms{};

	Parms.TownName = std::move(TownName);
	Parms.FlagPattern = FlagPattern;
	Parms.FlagColor = FlagColor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SetModeLoadout
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const struct FFortSavedModeLoadout&     ModeLoadout                                            (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    HeroId                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortSavedModeLoadout&     HeroModeLoadout                                        (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SetModeLoadout(const struct FFortSavedModeLoadout& ModeLoadout, const class FString& HeroId, const struct FFortSavedModeLoadout& HeroModeLoadout, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SetModeLoadout");

	Params::FortMcpProfileAccount_SetModeLoadout Parms{};

	Parms.ModeLoadout = std::move(ModeLoadout);
	Parms.HeroId = std::move(HeroId);
	Parms.HeroModeLoadout = std::move(HeroModeLoadout);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.SkipTutorial
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::SkipTutorial(struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "SkipTutorial");

	Params::FortMcpProfileAccount_SkipTutorial Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UnloadWarehouse
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            ResourceTypes                                          (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UnloadWarehouse(const TArray<class FString>& ResourceTypes, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UnloadWarehouse");

	Params::FortMcpProfileAccount_UnloadWarehouse Parms{};

	Parms.ResourceTypes = std::move(ResourceTypes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UnslotAllWorkers
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            BuildingIds                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UnslotAllWorkers(const TArray<class FString>& BuildingIds, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UnslotAllWorkers");

	Params::FortMcpProfileAccount_UnslotAllWorkers Parms{};

	Parms.BuildingIds = std::move(BuildingIds);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpdateBuildingLevelAndRating
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    BuildingId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LastBuildingLevel                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LastBuildingRating                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpdateBuildingLevelAndRating(const class FString& BuildingId, int32 LastBuildingLevel, int32 LastBuildingRating, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpdateBuildingLevelAndRating");

	Params::FortMcpProfileAccount_UpdateBuildingLevelAndRating Parms{};

	Parms.BuildingId = std::move(BuildingId);
	Parms.LastBuildingLevel = LastBuildingLevel;
	Parms.LastBuildingRating = LastBuildingRating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpdateQuestClientObjectives
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<struct FFortQuestObjectiveCompletion>&Advance                                                (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpdateQuestClientObjectives(const TArray<struct FFortQuestObjectiveCompletion>& Advance, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpdateQuestClientObjectives");

	Params::FortMcpProfileAccount_UpdateQuestClientObjectives Parms{};

	Parms.Advance = std::move(Advance);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpdateQuests
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<struct FFortQuestObjectiveCompletion>&Advance                                                (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpdateQuests(const TArray<struct FFortQuestObjectiveCompletion>& Advance, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpdateQuests");

	Params::FortMcpProfileAccount_UpdateQuests Parms{};

	Parms.Advance = std::move(Advance);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpgradeBuilding
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    BuildingId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpgradeBuilding(const class FString& BuildingId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpgradeBuilding");

	Params::FortMcpProfileAccount_UpgradeBuilding Parms{};

	Parms.BuildingId = std::move(BuildingId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpgradeItem
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TargetItemId                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpgradeItem(const class FString& TargetItemId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpgradeItem");

	Params::FortMcpProfileAccount_UpgradeItem Parms{};

	Parms.TargetItemId = std::move(TargetItemId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileAccount.UpgradeWorker
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TargetWorkerId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FClientUrlContext*               Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileAccount::UpgradeWorker(const class FString& TargetWorkerId, struct FClientUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileAccount", "UpgradeWorker");

	Params::FortMcpProfileAccount_UpgradeWorker Parms{};

	Parms.TargetWorkerId = std::move(TargetWorkerId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMissionPowerPointsInterface.GetAvailabilityWeight
// (Native, Public, Const)
// Parameters:
// float                                   DifficultyLevel                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortMissionPowerPointsInterface::GetAvailabilityWeight(float DifficultyLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionPowerPointsInterface", "GetAvailabilityWeight");

	Params::FortMissionPowerPointsInterface_GetAvailabilityWeight Parms{};

	Parms.DifficultyLevel = DifficultyLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionPowerPointsInterface.GetInitialRangeLerpValue
// (Native, Public, Const)
// Parameters:
// float                                   PointsAvailable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortMissionPowerPointsInterface::GetInitialRangeLerpValue(float PointsAvailable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionPowerPointsInterface", "GetInitialRangeLerpValue");

	Params::FortMissionPowerPointsInterface_GetInitialRangeLerpValue Parms{};

	Parms.PointsAvailable = PointsAvailable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionPowerPointsInterface.GetMaxRangeLerpValue
// (Native, Public, Const)
// Parameters:
// float                                   PointsAvailable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PreviousLerpValue                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortMissionPowerPointsInterface::GetMaxRangeLerpValue(float PointsAvailable, float PreviousLerpValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionPowerPointsInterface", "GetMaxRangeLerpValue");

	Params::FortMissionPowerPointsInterface_GetMaxRangeLerpValue Parms{};

	Parms.PointsAvailable = PointsAvailable;
	Parms.PreviousLerpValue = PreviousLerpValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionPowerPointsInterface.GetPowerPointsCost
// (Native, Public, Const)
// Parameters:
// float                                   LerpValue                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortMissionPowerPointsInterface::GetPowerPointsCost(float LerpValue) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionPowerPointsInterface", "GetPowerPointsCost");

	Params::FortMissionPowerPointsInterface_GetPowerPointsCost Parms{};

	Parms.LerpValue = LerpValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDroppedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UFortWorldItemDefinition**        _DroppedItemDefinition                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _DroppedBy                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  _AmountCollected                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemDroppedParams::BreakData(class UFortWorldItemDefinition** _DroppedItemDefinition, class AFortPlayerController** _DroppedBy, int32* _AmountCollected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDroppedParams", "BreakData");

	Params::FortItemDroppedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_DroppedItemDefinition != nullptr)
		*_DroppedItemDefinition = Parms._DroppedItemDefinition;

	if (_DroppedBy != nullptr)
		*_DroppedBy = Parms._DroppedBy;

	if (_AmountCollected != nullptr)
		*_AmountCollected = Parms._AmountCollected;
}


// Function FortniteGame.FortItemDroppedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UFortWorldItemDefinition*   _DroppedItemDefinition                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _DroppedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _AmountCollected                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItemDroppedParams**          ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemDroppedParams::MakeData(const class UFortWorldItemDefinition* _DroppedItemDefinition, class AFortPlayerController* _DroppedBy, int32 _AmountCollected, class UFortItemDroppedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDroppedParams", "MakeData");

	Params::FortItemDroppedParams_MakeData Parms{};

	Parms._DroppedItemDefinition = _DroppedItemDefinition;
	Parms._DroppedBy = _DroppedBy;
	Parms._AmountCollected = _AmountCollected;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortItemCraftedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UFortSchematicItemDefinition**    _SchematicDefinition                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _CraftedBy                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  _AmountCrafted                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCraftedParams::BreakData(class UFortSchematicItemDefinition** _SchematicDefinition, class AFortPlayerController** _CraftedBy, int32* _AmountCrafted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCraftedParams", "BreakData");

	Params::FortItemCraftedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_SchematicDefinition != nullptr)
		*_SchematicDefinition = Parms._SchematicDefinition;

	if (_CraftedBy != nullptr)
		*_CraftedBy = Parms._CraftedBy;

	if (_AmountCrafted != nullptr)
		*_AmountCrafted = Parms._AmountCrafted;
}


// Function FortniteGame.FortItemCraftedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UFortSchematicItemDefinition*_SchematicDefinition                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _CraftedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   _AmountCrafted                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItemCraftedParams**          ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortItemCraftedParams::MakeData(const class UFortSchematicItemDefinition* _SchematicDefinition, class AFortPlayerController* _CraftedBy, int32 _AmountCrafted, class UFortItemCraftedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemCraftedParams", "MakeData");

	Params::FortItemCraftedParams_MakeData Parms{};

	Parms._SchematicDefinition = _SchematicDefinition;
	Parms._CraftedBy = _CraftedBy;
	Parms._AmountCrafted = _AmountCrafted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortEnemyKilledParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPawn**                       _KilledPawn                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _KilledBy                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortEnemyKilledParams::BreakData(class AFortPawn** _KilledPawn, class AFortPlayerController** _KilledBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortEnemyKilledParams", "BreakData");

	Params::FortEnemyKilledParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_KilledPawn != nullptr)
		*_KilledPawn = Parms._KilledPawn;

	if (_KilledBy != nullptr)
		*_KilledBy = Parms._KilledBy;
}


// Function FortniteGame.FortEnemyKilledParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPawn*                        _KilledPawn                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _KilledBy                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortEnemyKilledParams**          ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortEnemyKilledParams::MakeData(class AFortPawn* _KilledPawn, class AFortPlayerController* _KilledBy, class UFortEnemyKilledParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortEnemyKilledParams", "MakeData");

	Params::FortEnemyKilledParams_MakeData Parms{};

	Parms._KilledPawn = _KilledPawn;
	Parms._KilledBy = _KilledBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortEnemyDamagedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPawn**                       _DamagedPawn                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _DamagedBy                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  _DamageAmount                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortEnemyDamagedParams::BreakData(class AFortPawn** _DamagedPawn, class AFortPlayerController** _DamagedBy, float* _DamageAmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortEnemyDamagedParams", "BreakData");

	Params::FortEnemyDamagedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_DamagedPawn != nullptr)
		*_DamagedPawn = Parms._DamagedPawn;

	if (_DamagedBy != nullptr)
		*_DamagedBy = Parms._DamagedBy;

	if (_DamageAmount != nullptr)
		*_DamageAmount = Parms._DamageAmount;
}


// Function FortniteGame.FortEnemyDamagedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPawn*                        _DamagedPawn                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _DamagedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   _DamageAmount                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortEnemyDamagedParams**         ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortEnemyDamagedParams::MakeData(class AFortPawn* _DamagedPawn, class AFortPlayerController* _DamagedBy, float _DamageAmount, class UFortEnemyDamagedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortEnemyDamagedParams", "MakeData");

	Params::FortEnemyDamagedParams_MakeData Parms{};

	Parms._DamagedPawn = _DamagedPawn;
	Parms._DamagedBy = _DamagedBy;
	Parms._DamageAmount = _DamageAmount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortNewPlayerParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController**           _NewPlayerController                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortNewPlayerParams::BreakData(class AFortPlayerController** _NewPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortNewPlayerParams", "BreakData");

	Params::FortNewPlayerParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_NewPlayerController != nullptr)
		*_NewPlayerController = Parms._NewPlayerController;
}


// Function FortniteGame.FortNewPlayerParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            _NewPlayerController                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortNewPlayerParams**            ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortNewPlayerParams::MakeData(class AFortPlayerController* _NewPlayerController, class UFortNewPlayerParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortNewPlayerParams", "MakeData");

	Params::FortNewPlayerParams_MakeData Parms{};

	Parms._NewPlayerController = _NewPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortPlayerSpawnedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController**           _SpawnedPlayerController                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerSpawnedParams::BreakData(class AFortPlayerController** _SpawnedPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerSpawnedParams", "BreakData");

	Params::FortPlayerSpawnedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_SpawnedPlayerController != nullptr)
		*_SpawnedPlayerController = Parms._SpawnedPlayerController;
}


// Function FortniteGame.FortPlayerSpawnedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            _SpawnedPlayerController                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortPlayerSpawnedParams**        ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerSpawnedParams::MakeData(class AFortPlayerController* _SpawnedPlayerController, class UFortPlayerSpawnedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerSpawnedParams", "MakeData");

	Params::FortPlayerSpawnedParams_MakeData Parms{};

	Parms._SpawnedPlayerController = _SpawnedPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortPlayerDiedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerPawn**                 _KilledPlayer                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController**                     _KilledBy                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerDiedParams::BreakData(class AFortPlayerPawn** _KilledPlayer, class AController** _KilledBy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerDiedParams", "BreakData");

	Params::FortPlayerDiedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_KilledPlayer != nullptr)
		*_KilledPlayer = Parms._KilledPlayer;

	if (_KilledBy != nullptr)
		*_KilledBy = Parms._KilledBy;
}


// Function FortniteGame.FortPlayerDiedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerPawn*                  _KilledPlayer                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      _KilledBy                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortPlayerDiedParams**           ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerDiedParams::MakeData(class AFortPlayerPawn* _KilledPlayer, class AController* _KilledBy, class UFortPlayerDiedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerDiedParams", "MakeData");

	Params::FortPlayerDiedParams_MakeData Parms{};

	Parms._KilledPlayer = _KilledPlayer;
	Parms._KilledBy = _KilledBy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortDayPhaseChangeParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortDayNightLightingAndFog**     _LightingAndFogManager                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase*                          _NewDayPhase                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortDayPhaseChangeParams::BreakData(class AFortDayNightLightingAndFog** _LightingAndFogManager, EFortDayPhase* _NewDayPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayPhaseChangeParams", "BreakData");

	Params::FortDayPhaseChangeParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_LightingAndFogManager != nullptr)
		*_LightingAndFogManager = Parms._LightingAndFogManager;

	if (_NewDayPhase != nullptr)
		*_NewDayPhase = Parms._NewDayPhase;
}


// Function FortniteGame.FortDayPhaseChangeParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortDayNightLightingAndFog*      _LightingAndFogManager                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           _NewDayPhase                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortDayPhaseChangeParams**       ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortDayPhaseChangeParams::MakeData(class AFortDayNightLightingAndFog* _LightingAndFogManager, EFortDayPhase _NewDayPhase, class UFortDayPhaseChangeParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayPhaseChangeParams", "MakeData");

	Params::FortDayPhaseChangeParams_MakeData Parms{};

	Parms._LightingAndFogManager = _LightingAndFogManager;
	Parms._NewDayPhase = _NewDayPhase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortPlayerBuiltParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class ABuildingActor**                  _Building                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType*                      _BuildingType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _Builder                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerBuiltParams::BreakData(class ABuildingActor** _Building, EFortBuildingType* _BuildingType, class AFortPlayerController** _Builder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerBuiltParams", "BreakData");

	Params::FortPlayerBuiltParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_Building != nullptr)
		*_Building = Parms._Building;

	if (_BuildingType != nullptr)
		*_BuildingType = Parms._BuildingType;

	if (_Builder != nullptr)
		*_Builder = Parms._Builder;
}


// Function FortniteGame.FortPlayerBuiltParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   _Building                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType                       _BuildingType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _Builder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortPlayerBuiltParams**          ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerBuiltParams::MakeData(class ABuildingActor* _Building, EFortBuildingType _BuildingType, class AFortPlayerController* _Builder, class UFortPlayerBuiltParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerBuiltParams", "MakeData");

	Params::FortPlayerBuiltParams_MakeData Parms{};

	Parms._Building = _Building;
	Parms._BuildingType = _BuildingType;
	Parms._Builder = _Builder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortBuildingDestroyedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class ABuildingActor**                  _Building                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType*                      _BuildingType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController**                     _Destroyer                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingDestroyedParams::BreakData(class ABuildingActor** _Building, EFortBuildingType* _BuildingType, class AController** _Destroyer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingDestroyedParams", "BreakData");

	Params::FortBuildingDestroyedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_Building != nullptr)
		*_Building = Parms._Building;

	if (_BuildingType != nullptr)
		*_BuildingType = Parms._BuildingType;

	if (_Destroyer != nullptr)
		*_Destroyer = Parms._Destroyer;
}


// Function FortniteGame.FortBuildingDestroyedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   _Building                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType                       _BuildingType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      _Destroyer                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortBuildingDestroyedParams**    ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingDestroyedParams::MakeData(class ABuildingActor* _Building, EFortBuildingType _BuildingType, class AController* _Destroyer, class UFortBuildingDestroyedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingDestroyedParams", "MakeData");

	Params::FortBuildingDestroyedParams_MakeData Parms{};

	Parms._Building = _Building;
	Parms._BuildingType = _BuildingType;
	Parms._Destroyer = _Destroyer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortBuildingEditedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class ABuildingActor**                  _OriginalBuilding                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuildingActor**                  _NewBuilding                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType*                      _BuildingType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController**           _Editor                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingEditedParams::BreakData(class ABuildingActor** _OriginalBuilding, class ABuildingActor** _NewBuilding, EFortBuildingType* _BuildingType, class AFortPlayerController** _Editor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingEditedParams", "BreakData");

	Params::FortBuildingEditedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_OriginalBuilding != nullptr)
		*_OriginalBuilding = Parms._OriginalBuilding;

	if (_NewBuilding != nullptr)
		*_NewBuilding = Parms._NewBuilding;

	if (_BuildingType != nullptr)
		*_BuildingType = Parms._BuildingType;

	if (_Editor != nullptr)
		*_Editor = Parms._Editor;
}


// Function FortniteGame.FortBuildingEditedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   _OriginalBuilding                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuildingActor*                   _NewBuilding                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType                       _BuildingType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            _Editor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortBuildingEditedParams**       ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingEditedParams::MakeData(class ABuildingActor* _OriginalBuilding, class ABuildingActor* _NewBuilding, EFortBuildingType _BuildingType, class AFortPlayerController* _Editor, class UFortBuildingEditedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingEditedParams", "MakeData");

	Params::FortBuildingEditedParams_MakeData Parms{};

	Parms._OriginalBuilding = _OriginalBuilding;
	Parms._NewBuilding = _NewBuilding;
	Parms._BuildingType = _BuildingType;
	Parms._Editor = _Editor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortBuildingDamagedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class ABuildingActor**                  _Building                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType*                      _BuildingType                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController**                     _DamagedBy                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  _DamageAmount                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingDamagedParams::BreakData(class ABuildingActor** _Building, EFortBuildingType* _BuildingType, class AController** _DamagedBy, float* _DamageAmount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingDamagedParams", "BreakData");

	Params::FortBuildingDamagedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_Building != nullptr)
		*_Building = Parms._Building;

	if (_BuildingType != nullptr)
		*_BuildingType = Parms._BuildingType;

	if (_DamagedBy != nullptr)
		*_DamagedBy = Parms._DamagedBy;

	if (_DamageAmount != nullptr)
		*_DamageAmount = Parms._DamageAmount;
}


// Function FortniteGame.FortBuildingDamagedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   _Building                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingType                       _BuildingType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      _DamagedBy                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   _DamageAmount                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortBuildingDamagedParams**      ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortBuildingDamagedParams::MakeData(class ABuildingActor* _Building, EFortBuildingType _BuildingType, class AController* _DamagedBy, float _DamageAmount, class UFortBuildingDamagedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingDamagedParams", "MakeData");

	Params::FortBuildingDamagedParams_MakeData Parms{};

	Parms._Building = _Building;
	Parms._BuildingType = _BuildingType;
	Parms._DamagedBy = _DamagedBy;
	Parms._DamageAmount = _DamageAmount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortMissionSucceededParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortMission**                    _SucceededMission                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionSucceededParams::BreakData(class AFortMission** _SucceededMission)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionSucceededParams", "BreakData");

	Params::FortMissionSucceededParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_SucceededMission != nullptr)
		*_SucceededMission = Parms._SucceededMission;
}


// Function FortniteGame.FortMissionSucceededParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortMission*                     _SucceededMission                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortMissionSucceededParams**     ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionSucceededParams::MakeData(class AFortMission* _SucceededMission, class UFortMissionSucceededParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionSucceededParams", "MakeData");

	Params::FortMissionSucceededParams_MakeData Parms{};

	Parms._SucceededMission = _SucceededMission;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortMissionFailedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortMission**                    _FailedMission                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionFailedParams::BreakData(class AFortMission** _FailedMission)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionFailedParams", "BreakData");

	Params::FortMissionFailedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_FailedMission != nullptr)
		*_FailedMission = Parms._FailedMission;
}


// Function FortniteGame.FortMissionFailedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortMission*                     _FailedMission                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortMissionFailedParams**        ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionFailedParams::MakeData(class AFortMission* _FailedMission, class UFortMissionFailedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionFailedParams", "MakeData");

	Params::FortMissionFailedParams_MakeData Parms{};

	Parms._FailedMission = _FailedMission;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortMissionNeutralCompleteParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortMission**                    _NeutrallyCompletedMission                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionNeutralCompleteParams::BreakData(class AFortMission** _NeutrallyCompletedMission)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionNeutralCompleteParams", "BreakData");

	Params::FortMissionNeutralCompleteParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_NeutrallyCompletedMission != nullptr)
		*_NeutrallyCompletedMission = Parms._NeutrallyCompletedMission;
}


// Function FortniteGame.FortMissionNeutralCompleteParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortMission*                     _NeutrallyCompletedMission                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortMissionNeutralCompleteParams**ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionNeutralCompleteParams::MakeData(class AFortMission* _NeutrallyCompletedMission, class UFortMissionNeutralCompleteParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionNeutralCompleteParams", "MakeData");

	Params::FortMissionNeutralCompleteParams_MakeData Parms{};

	Parms._NeutrallyCompletedMission = _NeutrallyCompletedMission;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortObjectiveSucceededParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortObjectiveBase**              _SucceededObjective                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveSucceededParams::BreakData(class AFortObjectiveBase** _SucceededObjective)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveSucceededParams", "BreakData");

	Params::FortObjectiveSucceededParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_SucceededObjective != nullptr)
		*_SucceededObjective = Parms._SucceededObjective;
}


// Function FortniteGame.FortObjectiveSucceededParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortObjectiveBase*               _SucceededObjective                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortObjectiveSucceededParams**   ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveSucceededParams::MakeData(class AFortObjectiveBase* _SucceededObjective, class UFortObjectiveSucceededParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveSucceededParams", "MakeData");

	Params::FortObjectiveSucceededParams_MakeData Parms{};

	Parms._SucceededObjective = _SucceededObjective;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortObjectiveFailedParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortObjectiveBase**              _FailedObjective                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveFailedParams::BreakData(class AFortObjectiveBase** _FailedObjective)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveFailedParams", "BreakData");

	Params::FortObjectiveFailedParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_FailedObjective != nullptr)
		*_FailedObjective = Parms._FailedObjective;
}


// Function FortniteGame.FortObjectiveFailedParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortObjectiveBase*               _FailedObjective                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortObjectiveFailedParams**      ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveFailedParams::MakeData(class AFortObjectiveBase* _FailedObjective, class UFortObjectiveFailedParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveFailedParams", "MakeData");

	Params::FortObjectiveFailedParams_MakeData Parms{};

	Parms._FailedObjective = _FailedObjective;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortObjectiveNeutralCompleteParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortObjectiveBase**              _NeutrallyCompletedObjective                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveNeutralCompleteParams::BreakData(class AFortObjectiveBase** _NeutrallyCompletedObjective)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveNeutralCompleteParams", "BreakData");

	Params::FortObjectiveNeutralCompleteParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_NeutrallyCompletedObjective != nullptr)
		*_NeutrallyCompletedObjective = Parms._NeutrallyCompletedObjective;
}


// Function FortniteGame.FortObjectiveNeutralCompleteParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortObjectiveBase*               _NeutrallyCompletedObjective                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortObjectiveNeutralCompleteParams**ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortObjectiveNeutralCompleteParams::MakeData(class AFortObjectiveBase* _NeutrallyCompletedObjective, class UFortObjectiveNeutralCompleteParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveNeutralCompleteParams", "MakeData");

	Params::FortObjectiveNeutralCompleteParams_MakeData Parms{};

	Parms._NeutrallyCompletedObjective = _NeutrallyCompletedObjective;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortToggledCursorModeParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController**           _PlayerThatToggledCursorMode                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   InCursorMode                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortToggledCursorModeParams::BreakData(class AFortPlayerController** _PlayerThatToggledCursorMode, bool* InCursorMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledCursorModeParams", "BreakData");

	Params::FortToggledCursorModeParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_PlayerThatToggledCursorMode != nullptr)
		*_PlayerThatToggledCursorMode = Parms._PlayerThatToggledCursorMode;

	if (InCursorMode != nullptr)
		*InCursorMode = Parms.InCursorMode;
}


// Function FortniteGame.FortToggledCursorModeParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            _PlayerThatToggledCursorMode                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InCursorMode                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortToggledCursorModeParams**    ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortToggledCursorModeParams::MakeData(class AFortPlayerController* _PlayerThatToggledCursorMode, bool InCursorMode, class UFortToggledCursorModeParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledCursorModeParams", "MakeData");

	Params::FortToggledCursorModeParams_MakeData Parms{};

	Parms._PlayerThatToggledCursorMode = _PlayerThatToggledCursorMode;
	Parms.InCursorMode = InCursorMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortToggledOptionsMenuParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController**           _PlayerThatToggledOptionsMenu                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   Opened                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortToggledOptionsMenuParams::BreakData(class AFortPlayerController** _PlayerThatToggledOptionsMenu, bool* Opened)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledOptionsMenuParams", "BreakData");

	Params::FortToggledOptionsMenuParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_PlayerThatToggledOptionsMenu != nullptr)
		*_PlayerThatToggledOptionsMenu = Parms._PlayerThatToggledOptionsMenu;

	if (Opened != nullptr)
		*Opened = Parms.Opened;
}


// Function FortniteGame.FortToggledOptionsMenuParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            _PlayerThatToggledOptionsMenu                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Opened                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortToggledOptionsMenuParams**   ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortToggledOptionsMenuParams::MakeData(class AFortPlayerController* _PlayerThatToggledOptionsMenu, bool Opened, class UFortToggledOptionsMenuParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledOptionsMenuParams", "MakeData");

	Params::FortToggledOptionsMenuParams_MakeData Parms{};

	Parms._PlayerThatToggledOptionsMenu = _PlayerThatToggledOptionsMenu;
	Parms.Opened = Opened;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortToggledEditModeParams.BreakData
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController**           _PlayerThatToggledEditMode                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   InEditMode                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortToggledEditModeParams::BreakData(class AFortPlayerController** _PlayerThatToggledEditMode, bool* InEditMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledEditModeParams", "BreakData");

	Params::FortToggledEditModeParams_BreakData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (_PlayerThatToggledEditMode != nullptr)
		*_PlayerThatToggledEditMode = Parms._PlayerThatToggledEditMode;

	if (InEditMode != nullptr)
		*InEditMode = Parms.InEditMode;
}


// Function FortniteGame.FortToggledEditModeParams.MakeData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            _PlayerThatToggledEditMode                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InEditMode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortToggledEditModeParams**      ThisParam                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortToggledEditModeParams::MakeData(class AFortPlayerController* _PlayerThatToggledEditMode, bool InEditMode, class UFortToggledEditModeParams** ThisParam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortToggledEditModeParams", "MakeData");

	Params::FortToggledEditModeParams_MakeData Parms{};

	Parms._PlayerThatToggledEditMode = _PlayerThatToggledEditMode;
	Parms.InEditMode = InEditMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ThisParam != nullptr)
		*ThisParam = Parms.ThisParam;
}


// Function FortniteGame.FortInitializationInterface.IsGameImportant
// (Native, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInitializationInterface::IsGameImportant()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInitializationInterface", "IsGameImportant");

	Params::FortInitializationInterface_IsGameImportant Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInitializationInterface.MatchStarted
// (Native, Public)

void IFortInitializationInterface::MatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInitializationInterface", "MatchStarted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortInitializationInterface.NeedsWorldReady
// (Native, Public)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInitializationInterface::NeedsWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInitializationInterface", "NeedsWorldReady");

	Params::FortInitializationInterface_NeedsWorldReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInitializationInterface.WorldReady
// (Native, Public)

void IFortInitializationInterface::WorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInitializationInterface", "WorldReady");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionState.OnMatchStarted
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortMissionState::OnMatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionState", "OnMatchStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortMissionState.OnWorldReady
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortMissionState::OnWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionState", "OnWorldReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortObjectiveBase.AttemptMissionSave
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    OptionalSaveName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::AttemptMissionSave(const class FString& OptionalSaveName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "AttemptMissionSave");

	Params::FortObjectiveBase_AttemptMissionSave Parms{};

	Parms.OptionalSaveName = std::move(OptionalSaveName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.BlueprintHandleMissionEventNoReply
// (BlueprintAuthorityOnly, Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortObjectiveBase::BlueprintHandleMissionEventNoReply(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintHandleMissionEventNoReply");

	Params::FortObjectiveBase_BlueprintHandleMissionEventNoReply Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortObjectiveBase.BlueprintOnActivated
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           InObjectiveFocus                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        InObjectiveInstigator                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::BlueprintOnActivated(class AActor* InObjectiveFocus, class AFortPawn* InObjectiveInstigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintOnActivated");

	Params::FortObjectiveBase_BlueprintOnActivated Parms{};

	Parms.InObjectiveFocus = InObjectiveFocus;
	Parms.InObjectiveInstigator = InObjectiveInstigator;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortObjectiveBase.BlueprintOnObjectiveEnd
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)
// Parameters:
// EFortObjectiveStatus                    Status                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::BlueprintOnObjectiveEnd(EFortObjectiveStatus Status)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintOnObjectiveEnd");

	Params::FortObjectiveBase_BlueprintOnObjectiveEnd Parms{};

	Parms.Status = Status;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortObjectiveBase.BlueprintOnStartPlaying
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           InObjectiveFocus                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        InObjectiveInstigator                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::BlueprintOnStartPlaying(class AActor* InObjectiveFocus, class AFortPawn* InObjectiveInstigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintOnStartPlaying");

	Params::FortObjectiveBase_BlueprintOnStartPlaying Parms{};

	Parms.InObjectiveFocus = InObjectiveFocus;
	Parms.InObjectiveInstigator = InObjectiveInstigator;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortObjectiveBase.BlueprintPostObjectiveLoad
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)

void AFortObjectiveBase::BlueprintPostObjectiveLoad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintPostObjectiveLoad");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortObjectiveBase.ClearObjectiveTimer
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void AFortObjectiveBase::ClearObjectiveTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "ClearObjectiveTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.DrawAttentionToUI
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortObjectiveBase::DrawAttentionToUI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "DrawAttentionToUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.EnableTick
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnabled                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortObjectiveBase::EnableTick(bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "EnableTick");

	Params::FortObjectiveBase_EnableTick Parms{};

	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.FocusParentMission
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bTemporaryFocus                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortObjectiveBase::FocusParentMission(bool bTemporaryFocus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "FocusParentMission");

	Params::FortObjectiveBase_FocusParentMission Parms{};

	Parms.bTemporaryFocus = bTemporaryFocus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.GrantRewardsByTag
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              RewardTag                                              (ConstParm, Parm, NativeAccessSpecifierPublic)
// EFortRewardType                         RewardType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::GrantRewardsByTag(const struct FGameplayTag& RewardTag, EFortRewardType RewardType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "GrantRewardsByTag");

	Params::FortObjectiveBase_GrantRewardsByTag Parms{};

	Parms.RewardTag = std::move(RewardTag);
	Parms.RewardType = RewardType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.OnMatchStarted
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)

void AFortObjectiveBase::OnMatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "OnMatchStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortObjectiveBase.OnRep_bIsObjectiveVisible
// (Final, Native, Protected)

void AFortObjectiveBase::OnRep_bIsObjectiveVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "OnRep_bIsObjectiveVisible");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.OnRep_ObjectiveStatus
// (Final, Native, Protected)

void AFortObjectiveBase::OnRep_ObjectiveStatus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "OnRep_ObjectiveStatus");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.OnWorldReady
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)

void AFortObjectiveBase::OnWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "OnWorldReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortObjectiveBase.PauseObjectiveTimer
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void AFortObjectiveBase::PauseObjectiveTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "PauseObjectiveTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.PlayerStatChanged
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerController*            OwningPlayer                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ChangedStat                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewValueZone                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewValueWorld                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NewValueAccount                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::PlayerStatChanged(class AFortPlayerController* OwningPlayer, class FName ChangedStat, int32 NewValueZone, int32 NewValueWorld, int32 NewValueAccount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "PlayerStatChanged");

	Params::FortObjectiveBase_PlayerStatChanged Parms{};

	Parms.OwningPlayer = OwningPlayer;
	Parms.ChangedStat = ChangedStat;
	Parms.NewValueZone = NewValueZone;
	Parms.NewValueWorld = NewValueWorld;
	Parms.NewValueAccount = NewValueAccount;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortObjectiveBase.ResetObjectiveTimer
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void AFortObjectiveBase::ResetObjectiveTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "ResetObjectiveTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.SetObjectiveTimer
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    FunctionName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimerLength                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStartPaused                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortObjectiveBase::SetObjectiveTimer(const class FString& FunctionName, float TimerLength, bool bStartPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "SetObjectiveTimer");

	Params::FortObjectiveBase_SetObjectiveTimer Parms{};

	Parms.FunctionName = std::move(FunctionName);
	Parms.TimerLength = TimerLength;
	Parms.bStartPaused = bStartPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.SetUiVisibility
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsObjectiveVisible                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortObjectiveBase::SetUiVisibility(bool bInIsObjectiveVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "SetUiVisibility");

	Params::FortObjectiveBase_SetUiVisibility Parms{};

	Parms.bInIsObjectiveVisible = bInIsObjectiveVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.StartMissionNotification
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortClientNotification>Notification                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpecificPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      OverrideDisplayText                                    (Parm, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn1                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn2                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             OptionalActionName                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USoundBase*                 OptionalSound                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTreatAsUnique                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelActiveNotification                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bWaitForClients                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortObjectiveBase::StartMissionNotification(const struct FLatentActionInfo& LatentInfo, TSubclassOf<class AFortClientNotification> Notification, class AFortPlayerController* SpecificPlayer, const class FText& OverrideDisplayText, class AFortPlayerPawn* OptionalPlayerPawn1, class AFortPlayerPawn* OptionalPlayerPawn2, class FName OptionalActionName, const class USoundBase* OptionalSound, bool bTreatAsUnique, bool bCancelActiveNotification, bool bWaitForClients)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "StartMissionNotification");

	Params::FortObjectiveBase_StartMissionNotification Parms{};

	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Notification = Notification;
	Parms.SpecificPlayer = SpecificPlayer;
	Parms.OverrideDisplayText = std::move(OverrideDisplayText);
	Parms.OptionalPlayerPawn1 = OptionalPlayerPawn1;
	Parms.OptionalPlayerPawn2 = OptionalPlayerPawn2;
	Parms.OptionalActionName = OptionalActionName;
	Parms.OptionalSound = OptionalSound;
	Parms.bTreatAsUnique = bTreatAsUnique;
	Parms.bCancelActiveNotification = bCancelActiveNotification;
	Parms.bWaitForClients = bWaitForClients;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.StartPlayingObjective
// (BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::StartPlayingObjective(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "StartPlayingObjective");

	Params::FortObjectiveBase_StartPlayingObjective Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.StopObjective
// (BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)
// Parameters:
// EFortObjectiveStatus                    Status                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Description                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     CompletionTags                                         (Parm, NativeAccessSpecifierPublic)
// class UFortBadgeItemDefinition*         ExtraBadgeToGrant                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortObjectiveBase::StopObjective(EFortObjectiveStatus Status, const class FString& Description, const struct FGameplayTagContainer& CompletionTags, class UFortBadgeItemDefinition* ExtraBadgeToGrant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "StopObjective");

	Params::FortObjectiveBase_StopObjective Parms{};

	Parms.Status = Status;
	Parms.Description = std::move(Description);
	Parms.CompletionTags = std::move(CompletionTags);
	Parms.ExtraBadgeToGrant = ExtraBadgeToGrant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.UnpauseObjectiveTimer
// (Final, BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void AFortObjectiveBase::UnpauseObjectiveTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "UnpauseObjectiveTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetNumProgressBars
// (BlueprintCosmetic, Event, Protected, BlueprintEvent, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortObjectiveBase::BlueprintGetNumProgressBars() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetNumProgressBars");

	Params::FortObjectiveBase_BlueprintGetNumProgressBars Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetObjectiveDisplayText
// (BlueprintCosmetic, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortObjectiveBase::BlueprintGetObjectiveDisplayText() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetObjectiveDisplayText");

	Params::FortObjectiveBase_BlueprintGetObjectiveDisplayText Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetProgressBarColor
// (BlueprintCosmetic, Event, Protected, HasDefaults, BlueprintEvent, Const)
// Parameters:
// int32                                   ProgressBarIdx                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor AFortObjectiveBase::BlueprintGetProgressBarColor(int32 ProgressBarIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetProgressBarColor");

	Params::FortObjectiveBase_BlueprintGetProgressBarColor Parms{};

	Parms.ProgressBarIdx = ProgressBarIdx;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetProgressBarPercentage
// (BlueprintCosmetic, Event, Protected, BlueprintEvent, Const)
// Parameters:
// int32                                   ProgressBarIdx                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortObjectiveBase::BlueprintGetProgressBarPercentage(int32 ProgressBarIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetProgressBarPercentage");

	Params::FortObjectiveBase_BlueprintGetProgressBarPercentage Parms{};

	Parms.ProgressBarIdx = ProgressBarIdx;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetProgressBarText
// (BlueprintCosmetic, Event, Protected, BlueprintEvent, Const)
// Parameters:
// int32                                   ProgressBarIdx                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortObjectiveBase::BlueprintGetProgressBarText(int32 ProgressBarIdx) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetProgressBarText");

	Params::FortObjectiveBase_BlueprintGetProgressBarText Parms{};

	Parms.ProgressBarIdx = ProgressBarIdx;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.BlueprintGetTimeForUI
// (BlueprintCosmetic, Event, Protected, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortObjectiveBase::BlueprintGetTimeForUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "BlueprintGetTimeForUI");

	Params::FortObjectiveBase_BlueprintGetTimeForUI Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.GetMissionGuid
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGuid                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FGuid AFortObjectiveBase::GetMissionGuid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "GetMissionGuid");

	Params::FortObjectiveBase_GetMissionGuid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.GetObjectiveTimerNormalizedTime
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortObjectiveBase::GetObjectiveTimerNormalizedTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "GetObjectiveTimerNormalizedTime");

	Params::FortObjectiveBase_GetObjectiveTimerNormalizedTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.GetObjectiveTimerTimeRemaining
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortObjectiveBase::GetObjectiveTimerTimeRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "GetObjectiveTimerTimeRemaining");

	Params::FortObjectiveBase_GetObjectiveTimerTimeRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.IsActorRelevantToTeam
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::IsActorRelevantToTeam(const class AActor* Actor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "IsActorRelevantToTeam");

	Params::FortObjectiveBase_IsActorRelevantToTeam Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.IsObjectiveTimerPaused
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::IsObjectiveTimerPaused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "IsObjectiveTimerPaused");

	Params::FortObjectiveBase_IsObjectiveTimerPaused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.IsObjectiveTimerSet
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::IsObjectiveTimerSet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "IsObjectiveTimerSet");

	Params::FortObjectiveBase_IsObjectiveTimerSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.IsRelevantToASpecificTeam
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::IsRelevantToASpecificTeam() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "IsRelevantToASpecificTeam");

	Params::FortObjectiveBase_IsRelevantToASpecificTeam Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortObjectiveBase.IsRelevantToTeam
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortObjectiveBase::IsRelevantToTeam(EFortTeam Team) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortObjectiveBase", "IsRelevantToTeam");

	Params::FortObjectiveBase_IsRelevantToTeam Parms{};

	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.CustomCharacterPartModifier.OnDayPhaseChanged
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ACustomCharacterPartModifier::OnDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartModifier", "OnDayPhaseChanged");

	Params::CustomCharacterPartModifier_OnDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.CustomCharacterPartModifier.PreDestruction
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ACustomCharacterPartModifier::PreDestruction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartModifier", "PreDestruction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.CustomCharacterPartModifier.GetAssociatedPlayerPawn
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerPawn*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerPawn* ACustomCharacterPartModifier::GetAssociatedPlayerPawn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartModifier", "GetAssociatedPlayerPawn");

	Params::CustomCharacterPartModifier_GetAssociatedPlayerPawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.CustomCharacterPartModifier.GetCharacterPartType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EFortCustomPartType               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const EFortCustomPartType ACustomCharacterPartModifier::GetCharacterPartType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartModifier", "GetCharacterPartType");

	Params::CustomCharacterPartModifier_GetCharacterPartType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInventory.HandleInventoryLocalUpdate
// (Final, Native, Public)

void AFortInventory::HandleInventoryLocalUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInventory", "HandleInventoryLocalUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWorldItemDefinition.CanBeDisassembled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortWorldItemDefinition::CanBeDisassembled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorldItemDefinition", "CanBeDisassembled");

	Params::FortWorldItemDefinition_CanBeDisassembled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorldItemDefinition.GetDPSAtLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortWorldItemDefinition::GetDPSAtLevel(int32 ItemLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorldItemDefinition", "GetDPSAtLevel");

	Params::FortWorldItemDefinition_GetDPSAtLevel Parms{};

	Parms.ItemLevel = ItemLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorldItemDefinition.GetMaxDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortWorldItemDefinition::GetMaxDurability(int32 ItemLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorldItemDefinition", "GetMaxDurability");

	Params::FortWorldItemDefinition_GetMaxDurability Parms{};

	Parms.ItemLevel = ItemLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.AddControlPoint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortSpline::AddControlPoint(const struct FVector& Point, int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "AddControlPoint");

	Params::FortSpline_AddControlPoint Parms{};

	Parms.Point = std::move(Point);
	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.ClearSpline
// (Final, Native, Public, BlueprintCallable)

void UFortSpline::ClearSpline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "ClearSpline");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.DrawDebugSpline
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Steps                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LifeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Thickness                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPersistent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bJustDrawSpline                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   BasisLength                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortSpline::DrawDebugSpline(class UObject* WorldContextObject, int32 Steps, float LifeTime, float Thickness, bool bPersistent, bool bJustDrawSpline, float BasisLength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "DrawDebugSpline");

	Params::FortSpline_DrawDebugSpline Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Steps = Steps;
	Parms.LifeTime = LifeTime;
	Parms.Thickness = Thickness;
	Parms.bPersistent = bPersistent;
	Parms.bJustDrawSpline = bJustDrawSpline;
	Parms.BasisLength = BasisLength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.EnableConstantVelocity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ConstVelEnabled                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortSpline::EnableConstantVelocity(bool ConstVelEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "EnableConstantVelocity");

	Params::FortSpline_EnableConstantVelocity Parms{};

	Parms.ConstVelEnabled = ConstVelEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.SetDuration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InDuration                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortSpline::SetDuration(float InDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "SetDuration");

	Params::FortSpline_SetDuration Parms{};

	Parms.InDuration = InDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.SetupSpline
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<struct FVector>&           ControlPoints                                          (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   InDuration                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortSpline::SetupSpline(const TArray<struct FVector>& ControlPoints, float InDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "SetupSpline");

	Params::FortSpline_SetupSpline Parms{};

	Parms.ControlPoints = std::move(ControlPoints);
	Parms.InDuration = InDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSpline.GetBinormalFromTime
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetBinormalFromTime(float Time) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetBinormalFromTime");

	Params::FortSpline_GetBinormalFromTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSpline::GetDuration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetDuration");

	Params::FortSpline_GetDuration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetEndPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetEndPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetEndPoint");

	Params::FortSpline_GetEndPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetNormalFromTime
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetNormalFromTime(float Time) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetNormalFromTime");

	Params::FortSpline_GetNormalFromTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetNumberOfControlPoints
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortSpline::GetNumberOfControlPoints() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetNumberOfControlPoints");

	Params::FortSpline_GetNumberOfControlPoints Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetPositionFromTime
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetPositionFromTime(float Time) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetPositionFromTime");

	Params::FortSpline_GetPositionFromTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetSplineLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   StepSize                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSpline::GetSplineLength(float StepSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetSplineLength");

	Params::FortSpline_GetSplineLength Parms{};

	Parms.StepSize = StepSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetSplineLengthAtTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StepSize                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSpline::GetSplineLengthAtTime(float Time, float StepSize) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetSplineLengthAtTime");

	Params::FortSpline_GetSplineLengthAtTime Parms{};

	Parms.Time = Time;
	Parms.StepSize = StepSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetStartPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetStartPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetStartPoint");

	Params::FortSpline_GetStartPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetTangentFromTime
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortSpline::GetTangentFromTime(float Time) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetTangentFromTime");

	Params::FortSpline_GetTangentFromTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.GetVelocityCorrectedTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSpline::GetVelocityCorrectedTime(float Time) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "GetVelocityCorrectedTime");

	Params::FortSpline_GetVelocityCorrectedTime Parms{};

	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpline.IsValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortSpline::IsValid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpline", "IsValid");

	Params::FortSpline_IsValid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.CanInteract
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInteractInterface::CanInteract(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "CanInteract");

	Params::FortInteractInterface_CanInteract Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.CanShowContextInfo
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInteractInterface::CanShowContextInfo(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "CanShowContextInfo");

	Params::FortInteractInterface_CanShowContextInfo Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.GetContextInfo
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// struct FInteractContextInfo             ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FInteractContextInfo IFortInteractInterface::GetContextInfo(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "GetContextInfo");

	Params::FortInteractInterface_GetContextInfo Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.HasDisplayWidget
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInteractInterface::HasDisplayWidget(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "HasDisplayWidget");

	Params::FortInteractInterface_HasDisplayWidget Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.LocalBeginLongUse
// (Native, Public)

void IFortInteractInterface::LocalBeginLongUse()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "LocalBeginLongUse");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortInteractInterface.LocalOnAttemptInteract
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInteractInterface::LocalOnAttemptInteract(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "LocalOnAttemptInteract");

	Params::FortInteractInterface_LocalOnAttemptInteract Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortInteractInterface.LocalOnInterruptInteract
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void IFortInteractInterface::LocalOnInterruptInteract(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "LocalOnInterruptInteract");

	Params::FortInteractInterface_LocalOnInterruptInteract Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortInteractInterface.ServerOnAttemptInteract
// (Native, Public, HasOutParams)
// Parameters:
// const struct FInteractionType&          InteractType                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortInteractInterface::ServerOnAttemptInteract(const struct FInteractionType& InteractType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInteractInterface", "ServerOnAttemptInteract");

	Params::FortInteractInterface_ServerOnAttemptInteract Parms{};

	Parms.InteractType = std::move(InteractType);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPickup.GetDisplayName
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortPickup::GetDisplayName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickup", "GetDisplayName");

	Params::FortPickup_GetDisplayName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPickup.OnRep_PickupLocationData
// (Native, Protected)

void AFortPickup::OnRep_PickupLocationData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickup", "OnRep_PickupLocationData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPickup.OnRep_PickupOwnerData
// (Native, Protected)

void AFortPickup::OnRep_PickupOwnerData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickup", "OnRep_PickupOwnerData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPickup.OnRep_PrimaryPickupItemEntry
// (Native, Protected)

void AFortPickup::OnRep_PrimaryPickupItemEntry()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickup", "OnRep_PrimaryPickupItemEntry");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPickup.TossPickup
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   FinalLocation                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class APawn*                            ItemOwner                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OverrideMaxStackCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPickup::TossPickup(const struct FVector& FinalLocation, class APawn* ItemOwner, int32 OverrideMaxStackCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickup", "TossPickup");

	Params::FortPickup_TossPickup Parms{};

	Parms.FinalLocation = std::move(FinalLocation);
	Parms.ItemOwner = ItemOwner;
	Parms.OverrideMaxStackCount = OverrideMaxStackCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortFeedbackManager.GetAnnouncerPawn
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn_FeedbackAnnouncer*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPawn_FeedbackAnnouncer* AFortFeedbackManager::GetAnnouncerPawn(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortFeedbackManager", "GetAnnouncerPawn");

	Params::FortFeedbackManager_GetAnnouncerPawn Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortFeedbackManager.GetFeedbackManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortFeedbackManager*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortFeedbackManager* AFortFeedbackManager::GetFeedbackManager(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortFeedbackManager", "GetFeedbackManager");

	Params::FortFeedbackManager_GetFeedbackManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortFeedbackManager.SuppressProceduralFeedback
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class AController*>&       ControllersToSuppress                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void AFortFeedbackManager::SuppressProceduralFeedback(const TArray<class AController*>& ControllersToSuppress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFeedbackManager", "SuppressProceduralFeedback");

	Params::FortFeedbackManager_SuppressProceduralFeedback Parms{};

	Parms.ControllersToSuppress = std::move(ControllersToSuppress);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_SpawnProjectileAndWait.SpawnProjectileAndWait
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortProjectileBase>  Class_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           RequestedBy_0                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation_0                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation_0                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnDirection_0                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InitialSpeed_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnHit_0                      (Parm, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnExplode_0                  (Parm, NativeAccessSpecifierPublic)
// float                                   GravityScale_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           HomingTarget_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_SpawnProjectileAndWait*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_SpawnProjectileAndWait* UFortAbilityTask_SpawnProjectileAndWait::SpawnProjectileAndWait(class UObject* WorldContextObject, TSubclassOf<class AFortProjectileBase> Class_0, class AActor* RequestedBy_0, const struct FVector& SpawnLocation_0, const struct FRotator& SpawnRotation_0, const struct FRotator& SpawnDirection_0, float InitialSpeed_0, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnHit_0, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnExplode_0, float GravityScale_0, class AActor* HomingTarget_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_SpawnProjectileAndWait", "SpawnProjectileAndWait");

	Params::FortAbilityTask_SpawnProjectileAndWait_SpawnProjectileAndWait Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Class_0 = Class_0;
	Parms.RequestedBy_0 = RequestedBy_0;
	Parms.SpawnLocation_0 = std::move(SpawnLocation_0);
	Parms.SpawnRotation_0 = std::move(SpawnRotation_0);
	Parms.SpawnDirection_0 = std::move(SpawnDirection_0);
	Parms.InitialSpeed_0 = InitialSpeed_0;
	Parms.EffectContainerSpecToApplyOnHit_0 = std::move(EffectContainerSpecToApplyOnHit_0);
	Parms.EffectContainerSpecToApplyOnExplode_0 = std::move(EffectContainerSpecToApplyOnExplode_0);
	Parms.GravityScale_0 = GravityScale_0;
	Parms.HomingTarget_0 = HomingTarget_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_SpawnProjectileAndWait.BeginSpawningActor
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortProjectileBase>  Class_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortProjectileBase**             SpawnedActor                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAbilityTask_SpawnProjectileAndWait::BeginSpawningActor(class UObject* WorldContextObject, TSubclassOf<class AFortProjectileBase> Class_0, class AFortProjectileBase** SpawnedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_SpawnProjectileAndWait", "BeginSpawningActor");

	Params::FortAbilityTask_SpawnProjectileAndWait_BeginSpawningActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Class_0 = Class_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (SpawnedActor != nullptr)
		*SpawnedActor = Parms.SpawnedActor;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_SpawnProjectileAndWait.FinishSpawningActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortProjectileBase*              SpawnedActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAbilityTask_SpawnProjectileAndWait::FinishSpawningActor(class UObject* WorldContextObject, class AFortProjectileBase* SpawnedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_SpawnProjectileAndWait", "FinishSpawningActor");

	Params::FortAbilityTask_SpawnProjectileAndWait_FinishSpawningActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SpawnedActor = SpawnedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_SpawnProjectileAndWait.OnProjectileDestroyed
// (Final, Native, Public)

void UFortAbilityTask_SpawnProjectileAndWait::OnProjectileDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_SpawnProjectileAndWait", "OnProjectileDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfoOwnerInterface.GetEncounterInfo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* IFortAIEncounterInfoOwnerInterface::GetEncounterInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfoOwnerInterface", "GetEncounterInfo");

	Params::FortAIEncounterInfoOwnerInterface_GetEncounterInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTeamActorInterface.GetTeam
// (Native, Public, Const)
// Parameters:
// EFortTeam                               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortTeam IFortTeamActorInterface::GetTeam() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamActorInterface", "GetTeam");

	Params::FortTeamActorInterface_GetTeam Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIGoalProvider.InitializeGoalProvider
// (Native, Public, BlueprintCallable)
// Parameters:
// class UWorld*                           ContextWorld                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignment*                Assignment                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIGoalProvider::InitializeGoalProvider(class UWorld* ContextWorld, class UFortAIAssignment* Assignment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalProvider", "InitializeGoalProvider");

	Params::FortAIGoalProvider_InitializeGoalProvider Parms{};

	Parms.ContextWorld = ContextWorld;
	Parms.Assignment = Assignment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIGoalProvider.UpdateGoals
// (Native, Public, BlueprintCallable)

void UFortAIGoalProvider::UpdateGoals()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalProvider", "UpdateGoals");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalProvider.GetEncounterInfo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* UFortAIGoalProvider::GetEncounterInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalProvider", "GetEncounterInfo");

	Params::FortAIGoalProvider_GetEncounterInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTargetSelectionInterface.GetTargetingTransform
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAbilityTargetingSource             Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortGameplayAbility*             SourceAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform IFortTargetSelectionInterface::GetTargetingTransform(EFortAbilityTargetingSource Source, class UFortGameplayAbility* SourceAbility) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTargetSelectionInterface", "GetTargetingTransform");

	Params::FortTargetSelectionInterface_GetTargetingTransform Parms{};

	Parms.Source = Source;
	Parms.SourceAbility = SourceAbility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_PlayMontageWaitTarget.PlayMontageInfoAndWaitForTrigger
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortGameplayAbilityMontageInfo&MontageInfo_0                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortAbilityTask_PlayMontageWaitTarget*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_PlayMontageWaitTarget* UFortAbilityTask_PlayMontageWaitTarget::PlayMontageInfoAndWaitForTrigger(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FFortGameplayAbilityMontageInfo& MontageInfo_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_PlayMontageWaitTarget", "PlayMontageInfoAndWaitForTrigger");

	Params::FortAbilityTask_PlayMontageWaitTarget_PlayMontageInfoAndWaitForTrigger Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.MontageInfo_0 = std::move(MontageInfo_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_PlayMontageWaitTarget.PlayMontageWaitTarget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AnimPlayRate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortGameplayAbilityMontageSectionToPlaySectionToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             OverrideSection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AnimRootMotionTranslationScale                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_PlayMontageWaitTarget*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_PlayMontageWaitTarget* UFortAbilityTask_PlayMontageWaitTarget::PlayMontageWaitTarget(class UObject* WorldContextObject, class FName TaskInstanceName, class UAnimMontage* MontageToPlay, float AnimPlayRate, EFortGameplayAbilityMontageSectionToPlay SectionToPlay, class FName OverrideSection, float AnimRootMotionTranslationScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_PlayMontageWaitTarget", "PlayMontageWaitTarget");

	Params::FortAbilityTask_PlayMontageWaitTarget_PlayMontageWaitTarget Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.MontageToPlay = MontageToPlay;
	Parms.AnimPlayRate = AnimPlayRate;
	Parms.SectionToPlay = SectionToPlay;
	Parms.OverrideSection = OverrideSection;
	Parms.AnimRootMotionTranslationScale = AnimRootMotionTranslationScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_PlayMontageWaitTarget.PlayMontageWithCharPartsWait
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortCharacterPartMontageInfo>&CharacterPartMontages                                  (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   AnimPlayRate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortGameplayAbilityMontageSectionToPlaySectionToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             OverrideSection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AnimRootMotionTranslationScale                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_PlayMontageWaitTarget*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_PlayMontageWaitTarget* UFortAbilityTask_PlayMontageWaitTarget::PlayMontageWithCharPartsWait(class UObject* WorldContextObject, class FName TaskInstanceName, class UAnimMontage* MontageToPlay, const TArray<struct FFortCharacterPartMontageInfo>& CharacterPartMontages, float AnimPlayRate, EFortGameplayAbilityMontageSectionToPlay SectionToPlay, class FName OverrideSection, float AnimRootMotionTranslationScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_PlayMontageWaitTarget", "PlayMontageWithCharPartsWait");

	Params::FortAbilityTask_PlayMontageWaitTarget_PlayMontageWithCharPartsWait Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.MontageToPlay = MontageToPlay;
	Parms.CharacterPartMontages = std::move(CharacterPartMontages);
	Parms.AnimPlayRate = AnimPlayRate;
	Parms.SectionToPlay = SectionToPlay;
	Parms.OverrideSection = OverrideSection;
	Parms.AnimRootMotionTranslationScale = AnimRootMotionTranslationScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_PlayMontageWaitTarget.OnTargetDataCancelledCallback
// (Final, Native, Public)

void UFortAbilityTask_PlayMontageWaitTarget::OnTargetDataCancelledCallback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_PlayMontageWaitTarget", "OnTargetDataCancelledCallback");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_PlayMontageWaitTarget.OnTargetDataReadyCallback
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAbilityTargetDataHandle&TargetData                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)

void UFortAbilityTask_PlayMontageWaitTarget::OnTargetDataReadyCallback(const struct FGameplayAbilityTargetDataHandle& TargetData, const struct FGameplayTag& ApplicationTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_PlayMontageWaitTarget", "OnTargetDataReadyCallback");

	Params::FortAbilityTask_PlayMontageWaitTarget_OnTargetDataReadyCallback Parms{};

	Parms.TargetData = std::move(TargetData);
	Parms.ApplicationTag = std::move(ApplicationTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.AlignRotationTo4WaysHitReaction
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   HitDirection                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   FrontOffset                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BackOffset                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LeftOffset                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RightOffset                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::AlignRotationTo4WaysHitReaction(const struct FVector& HitDirection, float FrontOffset, float BackOffset, float LeftOffset, float RightOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "AlignRotationTo4WaysHitReaction");

	Params::FortPawn_AlignRotationTo4WaysHitReaction Parms{};

	Parms.HitDirection = std::move(HitDirection);
	Parms.FrontOffset = FrontOffset;
	Parms.BackOffset = BackOffset;
	Parms.LeftOffset = LeftOffset;
	Parms.RightOffset = RightOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.AlignRotationToHitDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   HitDirection                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::AlignRotationToHitDirection(const struct FVector& HitDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "AlignRotationToHitDirection");

	Params::FortPawn_AlignRotationToHitDirection Parms{};

	Parms.HitDirection = std::move(HitDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.AnimMontage_LocalJumpToSectionName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::AnimMontage_LocalJumpToSectionName(class FName SectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "AnimMontage_LocalJumpToSectionName");

	Params::FortPawn_AnimMontage_LocalJumpToSectionName Parms{};

	Parms.SectionName = SectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.AnimMontage_LocalSetNextSectionName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     AnimMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextSectionName                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::AnimMontage_LocalSetNextSectionName(class UAnimMontage* AnimMontage, class FName SectionName, class FName NextSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "AnimMontage_LocalSetNextSectionName");

	Params::FortPawn_AnimMontage_LocalSetNextSectionName Parms{};

	Parms.AnimMontage = AnimMontage;
	Parms.SectionName = SectionName;
	Parms.NextSectionName = NextSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.ApplyKnockback
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                                   KnockbackMagnitude                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   KnockbackZAngle                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpulseDir                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::ApplyKnockback(float KnockbackMagnitude, float KnockbackZAngle, const struct FVector& ImpulseDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "ApplyKnockback");

	Params::FortPawn_ApplyKnockback Parms{};

	Parms.KnockbackMagnitude = KnockbackMagnitude;
	Parms.KnockbackZAngle = KnockbackZAngle;
	Parms.ImpulseDir = std::move(ImpulseDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.AttachAssetToSocket
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAssetAttachment&          InAttachment                                           (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortPawn::AttachAssetToSocket(const struct FAssetAttachment& InAttachment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "AttachAssetToSocket");

	Params::FortPawn_AttachAssetToSocket Parms{};

	Parms.InAttachment = std::move(InAttachment);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.ClientInternalEquipWeapon
// (Final, Net, NetReliable, Native, Event, Private, NetClient)
// Parameters:
// class AFortWeapon*                      Weap                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::ClientInternalEquipWeapon(class AFortWeapon* Weap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "ClientInternalEquipWeapon");

	Params::FortPawn_ClientInternalEquipWeapon Parms{};

	Parms.Weap = Weap;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.DetachAssetFromSocket
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::DetachAssetFromSocket(class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "DetachAssetFromSocket");

	Params::FortPawn_DetachAssetFromSocket Parms{};

	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.DoFatalDamage
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          KillerAbilitySystemComponent                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::DoFatalDamage(class UAbilitySystemComponent* KillerAbilitySystemComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "DoFatalDamage");

	Params::FortPawn_DoFatalDamage Parms{};

	Parms.KillerAbilitySystemComponent = KillerAbilitySystemComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.ForceKill
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              DeathReason                                            (Parm, NativeAccessSpecifierPublic)
// class AController*                      KillerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           KillerActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::ForceKill(const struct FGameplayTag& DeathReason, class AController* KillerController, class AActor* KillerActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "ForceKill");

	Params::FortPawn_ForceKill Parms{};

	Parms.DeathReason = std::move(DeathReason);
	Parms.KillerController = KillerController;
	Parms.KillerActor = KillerActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.GameplayCue
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortPawn::GameplayCue(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GameplayCue");

	Params::FortPawn_GameplayCue Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.GameplayCue_Damage
// (Native, Protected, BlueprintCallable)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortPawn::GameplayCue_Damage(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GameplayCue_Damage");

	Params::FortPawn_GameplayCue_Damage Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.GameplayCue_InstantDeath
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortPawn::GameplayCue_InstantDeath(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GameplayCue_InstantDeath");

	Params::FortPawn_GameplayCue_InstantDeath Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.GetAssetSkeletalMeshComponentAttachment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* AFortPawn::GetAssetSkeletalMeshComponentAttachment(class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetAssetSkeletalMeshComponentAttachment");

	Params::FortPawn_GetAssetSkeletalMeshComponentAttachment Parms{};

	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetAssetStaticMeshComponentAttachment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStaticMeshComponent* AFortPawn::GetAssetStaticMeshComponentAttachment(class FName SocketName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetAssetStaticMeshComponentAttachment");

	Params::FortPawn_GetAssetStaticMeshComponentAttachment Parms{};

	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetCurrentFeedbackDuration
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetCurrentFeedbackDuration()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetCurrentFeedbackDuration");

	Params::FortPawn_GetCurrentFeedbackDuration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetCurrentMontageSectionTimeLeft
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetCurrentMontageSectionTimeLeft()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetCurrentMontageSectionTimeLeft");

	Params::FortPawn_GetCurrentMontageSectionTimeLeft Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetFeedbackAudioComponent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UAudioComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAudioComponent* AFortPawn::GetFeedbackAudioComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetFeedbackAudioComponent");

	Params::FortPawn_GetFeedbackAudioComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetHealthPercent
// (Native, Public)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetHealthPercent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetHealthPercent");

	Params::FortPawn_GetHealthPercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMyMovementBaseActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortPawn::GetMyMovementBaseActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMyMovementBaseActor");

	Params::FortPawn_GetMyMovementBaseActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetPawnMID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ElementIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* AFortPawn::GetPawnMID(int32 ElementIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetPawnMID");

	Params::FortPawn_GetPawnMID Parms{};

	Parms.ElementIndex = ElementIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.HandleIsDying
// (Native, Public)

void AFortPawn::HandleIsDying()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "HandleIsDying");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.HandleIsHiddenForDeath
// (Native, Public)

void AFortPawn::HandleIsHiddenForDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "HandleIsHiddenForDeath");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.HideBodyOnDeath
// (Native, Public, BlueprintCallable)

void AFortPawn::HideBodyOnDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "HideBodyOnDeath");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.HoldAnimationFrames
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   StartTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HoldTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::HoldAnimationFrames(float StartTime, float HoldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "HoldAnimationFrames");

	Params::FortPawn_HoldAnimationFrames Parms{};

	Parms.StartTime = StartTime;
	Parms.HoldTime = HoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.InitializeDeathHitSocket
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldNormal                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::InitializeDeathHitSocket(const struct FVector& WorldLocation, const struct FVector& WorldNormal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "InitializeDeathHitSocket");

	Params::FortPawn_InitializeDeathHitSocket Parms{};

	Parms.WorldLocation = std::move(WorldLocation);
	Parms.WorldNormal = std::move(WorldNormal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnBaseChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                           NewBase                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::OnBaseChanged(class AActor* NewBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnBaseChanged");

	Params::FortPawn_OnBaseChanged Parms{};

	Parms.NewBase = NewBase;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnBumpPushedPawn
// (Event, Public, BlueprintEvent)
// Parameters:
// class AFortPawn*                        InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PushTimeLeft                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::OnBumpPushedPawn(class AFortPawn* InstigatedBy, float PushTimeLeft)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnBumpPushedPawn");

	Params::FortPawn_OnBumpPushedPawn Parms{};

	Parms.InstigatedBy = InstigatedBy;
	Parms.PushTimeLeft = PushTimeLeft;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnDamagePlayEffects
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void AFortPawn::OnDamagePlayEffects(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AFortPawn* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnDamagePlayEffects");

	Params::FortPawn_OnDamagePlayEffects Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnDamageServer
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void AFortPawn::OnDamageServer(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnDamageServer");

	Params::FortPawn_OnDamageServer Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnDamageZoneStatusChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortDamageZone                         Zone                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStatus                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::OnDamageZoneStatusChanged(EFortDamageZone Zone, bool bStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnDamageZoneStatusChanged");

	Params::FortPawn_OnDamageZoneStatusChanged Parms{};

	Parms.Zone = Zone;
	Parms.bStatus = bStatus;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnDeathPlayEffects
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void AFortPawn::OnDeathPlayEffects(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AFortPawn* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnDeathPlayEffects");

	Params::FortPawn_OnDeathPlayEffects Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnDeathServer
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void AFortPawn::OnDeathServer(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnDeathServer");

	Params::FortPawn_OnDeathServer Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.OnMontageEnded
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnMontageEnded");

	Params::FortPawn_OnMontageEnded Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnMontageStarted
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::OnMontageStarted(class UAnimMontage* Montage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnMontageStarted");

	Params::FortPawn_OnMontageStarted Parms{};

	Parms.Montage = Montage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_bWeaponHolstered
// (Final, Native, Public)

void AFortPawn::OnRep_bWeaponHolstered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_bWeaponHolstered");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_CurrentWeapon
// (Native, Public)

void AFortPawn::OnRep_CurrentWeapon()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_CurrentWeapon");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_DamageZoneActiveBitMask
// (Final, Native, Public)

void AFortPawn::OnRep_DamageZoneActiveBitMask()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_DamageZoneActiveBitMask");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_PawnUniqueID
// (Final, Native, Public)

void AFortPawn::OnRep_PawnUniqueID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_PawnUniqueID");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_PushMomentum
// (Final, Native, Private)

void AFortPawn::OnRep_PushMomentum()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_PushMomentum");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnRep_VocalChords
// (Native, Public)

void AFortPawn::OnRep_VocalChords()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnRep_VocalChords");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.OnStunned
// (BlueprintAuthorityOnly, Event, Public, BlueprintCallable, BlueprintEvent)

void AFortPawn::OnStunned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnStunned");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPawn.OnStunnedEffectBegin
// (BlueprintCosmetic, Event, Public, BlueprintCallable, BlueprintEvent)

void AFortPawn::OnStunnedEffectBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnStunnedEffectBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPawn.OnStunnedEffectEnd
// (BlueprintCosmetic, Event, Public, BlueprintCallable, BlueprintEvent)

void AFortPawn::OnStunnedEffectEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnStunnedEffectEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPawn.OnWeaponEquipped
// (Event, Public, BlueprintEvent)
// Parameters:
// class AFortWeapon*                      NewWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortWeapon*                      PrevWeapon                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::OnWeaponEquipped(class AFortWeapon* NewWeapon, class AFortWeapon* PrevWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "OnWeaponEquipped");

	Params::FortPawn_OnWeaponEquipped Parms{};

	Parms.NewWeapon = NewWeapon;
	Parms.PrevWeapon = PrevWeapon;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPawn.PawnUniqueIDSet
// (Event, Public, BlueprintEvent)

void AFortPawn::PawnUniqueIDSet()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PawnUniqueIDSet");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPawn.PickUpActor
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           PickupTarget                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortDecoItemDefinition*          PlacementDecoItemDefinition                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::PickUpActor(class AActor* PickupTarget, class UFortDecoItemDefinition* PlacementDecoItemDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PickUpActor");

	Params::FortPawn_PickUpActor Parms{};

	Parms.PickupTarget = PickupTarget;
	Parms.PlacementDecoItemDefinition = PlacementDecoItemDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.PlayFootStepSound
// (Native, Public, BlueprintCallable)
// Parameters:
// int32                                   FootDown                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::PlayFootStepSound(int32 FootDown)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PlayFootStepSound");

	Params::FortPawn_PlayFootStepSound Parms{};

	Parms.FootDown = FootDown;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.PlayHitReactionAdditiveCringe
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortPawn::PlayHitReactionAdditiveCringe()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PlayHitReactionAdditiveCringe");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.PlayLocalAnimMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*                     NewAnimMontage                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InPlayRate                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSectionName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::PlayLocalAnimMontage(class UAnimMontage* NewAnimMontage, float InPlayRate, class FName StartSectionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PlayLocalAnimMontage");

	Params::FortPawn_PlayLocalAnimMontage Parms{};

	Parms.NewAnimMontage = NewAnimMontage;
	Parms.InPlayRate = InPlayRate;
	Parms.StartSectionName = StartSectionName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.PlaySound
// (Net, Native, Event, Public, NetClient)
// Parameters:
// class USoundBase*                       Sound                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   VolumeMultiplier                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PitchMultiplier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::PlaySound(class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PlaySound");

	Params::FortPawn_PlaySound Parms{};

	Parms.Sound = Sound;
	Parms.VolumeMultiplier = VolumeMultiplier;
	Parms.PitchMultiplier = PitchMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.PrototypeCharacterMovement
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EMovementMode                           MovementMode                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LaunchVelocity                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::PrototypeCharacterMovement(EMovementMode MovementMode, const struct FVector& LaunchVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "PrototypeCharacterMovement");

	Params::FortPawn_PrototypeCharacterMovement Parms{};

	Parms.MovementMode = MovementMode;
	Parms.LaunchVelocity = std::move(LaunchVelocity);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.ServerInternalEquipWeapon
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class AFortWeapon*                      Weap                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::ServerInternalEquipWeapon(class AFortWeapon* Weap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "ServerInternalEquipWeapon");

	Params::FortPawn_ServerInternalEquipWeapon Parms{};

	Parms.Weap = Weap;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.ServerTeleportNearLocation
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FVector&                   ActorLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::ServerTeleportNearLocation(const struct FVector& ActorLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "ServerTeleportNearLocation");

	Params::FortPawn_ServerTeleportNearLocation Parms{};

	Parms.ActorLocation = std::move(ActorLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.SetDamageZoneActiveStatus
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortDamageZone                         Zone                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::SetDamageZoneActiveStatus(EFortDamageZone Zone, bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetDamageZoneActiveStatus");

	Params::FortPawn_SetDamageZoneActiveStatus Parms{};

	Parms.Zone = Zone;
	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.SetFNameBasedOnHitDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   HitDirection                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class FName*                            NameResult                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NameFront                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NameBack                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NameLeft                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NameRight                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::SetFNameBasedOnHitDirection(const struct FVector& HitDirection, class FName* NameResult, class FName NameFront, class FName NameBack, class FName NameLeft, class FName NameRight)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetFNameBasedOnHitDirection");

	Params::FortPawn_SetFNameBasedOnHitDirection Parms{};

	Parms.HitDirection = std::move(HitDirection);
	Parms.NameFront = NameFront;
	Parms.NameBack = NameBack;
	Parms.NameLeft = NameLeft;
	Parms.NameRight = NameRight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NameResult != nullptr)
		*NameResult = Parms.NameResult;
}


// Function FortniteGame.FortPawn.SetHealth
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewHealthVal                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::SetHealth(float NewHealthVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetHealth");

	Params::FortPawn_SetHealth Parms{};

	Parms.NewHealthVal = NewHealthVal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.SetHolsterWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bHolster                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::SetHolsterWeapon(bool bHolster)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetHolsterWeapon");

	Params::FortPawn_SetHolsterWeapon Parms{};

	Parms.bHolster = bHolster;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.SetPawnAndControlRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  NewRotation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::SetPawnAndControlRotation(const struct FRotator& NewRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetPawnAndControlRotation");

	Params::FortPawn_SetPawnAndControlRotation Parms{};

	Parms.NewRotation = std::move(NewRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.SetPawnVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewHidden                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPawn::SetPawnVisibility(bool bNewHidden)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "SetPawnVisibility");

	Params::FortPawn_SetPawnVisibility Parms{};

	Parms.bNewHidden = bNewHidden;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.StartPushMomentum
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewPushMomentum                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::StartPushMomentum(const struct FVector& NewPushMomentum, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "StartPushMomentum");

	Params::FortPawn_StartPushMomentum Parms{};

	Parms.NewPushMomentum = std::move(NewPushMomentum);
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.StealFromActor
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPawn*                        PawnToStealFrom                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::StealFromActor(class AFortPawn* PawnToStealFrom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "StealFromActor");

	Params::FortPawn_StealFromActor Parms{};

	Parms.PawnToStealFrom = PawnToStealFrom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.StopPushMomentum
// (Final, Native, Public, BlueprintCallable)

void AFortPawn::StopPushMomentum()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "StopPushMomentum");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.TriggerFeedbackEvent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatorPawn                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        Recipient                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OverriddenDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::TriggerFeedbackEvent(class FName EventName, class AFortPawn* InstigatorPawn, class AFortPawn* Recipient, float OverriddenDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "TriggerFeedbackEvent");

	Params::FortPawn_TriggerFeedbackEvent Parms{};

	Parms.EventName = EventName;
	Parms.InstigatorPawn = InstigatorPawn;
	Parms.Recipient = Recipient;
	Parms.OverriddenDelay = OverriddenDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn.GetAbilityDecisionWindowTriggerTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bPrimaryInput                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FGameplayTag                     ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayTag AFortPawn::GetAbilityDecisionWindowTriggerTag(bool bPrimaryInput) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetAbilityDecisionWindowTriggerTag");

	Params::FortPawn_GetAbilityDecisionWindowTriggerTag Parms{};

	Parms.bPrimaryInput = bPrimaryInput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetDamageZone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDamageZone                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortDamageZone AFortPawn::GetDamageZone(class FName BoneName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetDamageZone");

	Params::FortPawn_GetDamageZone Parms{};

	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetDefaultTargetingOrigin
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortPawn::GetDefaultTargetingOrigin() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetDefaultTargetingOrigin");

	Params::FortPawn_GetDefaultTargetingOrigin Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetDefaultTargetingRotation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AFortPawn::GetDefaultTargetingRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetDefaultTargetingRotation");

	Params::FortPawn_GetDefaultTargetingRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetEncounterInfo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* AFortPawn::GetEncounterInfo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetEncounterInfo");

	Params::FortPawn_GetEncounterInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetHealth
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetHealth");

	Params::FortPawn_GetHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMaxHealth
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetMaxHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMaxHealth");

	Params::FortPawn_GetMaxHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMaxShield
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetMaxShield() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMaxShield");

	Params::FortPawn_GetMaxShield Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMeleeComboCounter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortPawn::GetMeleeComboCounter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMeleeComboCounter");

	Params::FortPawn_GetMeleeComboCounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMeleeRange
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetMeleeRange() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMeleeRange");

	Params::FortPawn_GetMeleeRange Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMeleeReticleStrikeAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bPrimaryInput                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetMeleeReticleStrikeAngle(bool bPrimaryInput) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMeleeReticleStrikeAngle");

	Params::FortPawn_GetMeleeReticleStrikeAngle Parms{};

	Parms.bPrimaryInput = bPrimaryInput;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetMovementPredictionPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   PredictionDeltaTime                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortPawn::GetMovementPredictionPosition(float PredictionDeltaTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetMovementPredictionPosition");

	Params::FortPawn_GetMovementPredictionPosition Parms{};

	Parms.PredictionDeltaTime = PredictionDeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetShield
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPawn::GetShield() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetShield");

	Params::FortPawn_GetShield Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.GetSphericalHitDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   HitDirection                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  Azimuth                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Elevation                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn::GetSphericalHitDirection(const struct FVector& HitDirection, float* Azimuth, float* Elevation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetSphericalHitDirection");

	Params::FortPawn_GetSphericalHitDirection Parms{};

	Parms.HitDirection = std::move(HitDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Azimuth != nullptr)
		*Azimuth = Parms.Azimuth;

	if (Elevation != nullptr)
		*Elevation = Parms.Elevation;
}


// Function FortniteGame.FortPawn.GetTargetingTransform
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAbilityTargetingSource             Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortGameplayAbility*             SourceAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AFortPawn::GetTargetingTransform(EFortAbilityTargetingSource Source, class UFortGameplayAbility* SourceAbility) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "GetTargetingTransform");

	Params::FortPawn_GetTargetingTransform Parms{};

	Parms.Source = Source;
	Parms.SourceAbility = SourceAbility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.HasCurrentMontage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::HasCurrentMontage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "HasCurrentMontage");

	Params::FortPawn_HasCurrentMontage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.IsDamageZoneActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortDamageZone                         Zone                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::IsDamageZoneActive(EFortDamageZone Zone) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "IsDamageZoneActive");

	Params::FortPawn_IsDamageZoneActive Parms{};

	Parms.Zone = Zone;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.IsDead
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::IsDead() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "IsDead");

	Params::FortPawn_IsDead Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.IsFrontalHit
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   HitDirection                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::IsFrontalHit(const struct FVector& HitDirection) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "IsFrontalHit");

	Params::FortPawn_IsFrontalHit Parms{};

	Parms.HitDirection = std::move(HitDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn.IsWeaponHolstered
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn::IsWeaponHolstered() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn", "IsWeaponHolstered");

	Params::FortPawn_IsWeaponHolstered Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCarriedObjectHolderInterface.OnCarriedObjectAttach
// (Native, Public)
// Parameters:
// class AActor*                           AttachedObject                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortCarriedObjectHolderInterface::OnCarriedObjectAttach(class AActor* AttachedObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObjectHolderInterface", "OnCarriedObjectAttach");

	Params::FortCarriedObjectHolderInterface_OnCarriedObjectAttach Parms{};

	Parms.AttachedObject = AttachedObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCarriedObjectHolderInterface.OnCarriedObjectDetach
// (Native, Public)
// Parameters:
// class AActor*                           DetachedObject                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortCarriedObjectHolderInterface::OnCarriedObjectDetach(class AActor* DetachedObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObjectHolderInterface", "OnCarriedObjectDetach");

	Params::FortCarriedObjectHolderInterface_OnCarriedObjectDetach Parms{};

	Parms.DetachedObject = DetachedObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCarriedObjectHolderInterface.CanHoldObject
// (Native, Public, Const)
// Parameters:
// class AActor*                           CarriableObject                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortCarriedObjectHolderInterface::CanHoldObject(class AActor* CarriableObject) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObjectHolderInterface", "CanHoldObject");

	Params::FortCarriedObjectHolderInterface_CanHoldObject Parms{};

	Parms.CarriableObject = CarriableObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCarriedObjectHolderInterface.GetAttachmentComponent
// (Native, Public, Const)
// Parameters:
// class FName                             SocketName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USceneComponent* IFortCarriedObjectHolderInterface::GetAttachmentComponent(class FName SocketName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObjectHolderInterface", "GetAttachmentComponent");

	Params::FortCarriedObjectHolderInterface_GetAttachmentComponent Parms{};

	Parms.SocketName = SocketName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCarriedObjectHolderInterface.GetCarriedObjectAttachmentInfo
// (Native, Public, HasOutParams, Const)
// Parameters:
// struct FCarriedObjectAttachmentInfo*    OutAttachInfo                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void IFortCarriedObjectHolderInterface::GetCarriedObjectAttachmentInfo(struct FCarriedObjectAttachmentInfo* OutAttachInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCarriedObjectHolderInterface", "GetCarriedObjectAttachmentInfo");

	Params::FortCarriedObjectHolderInterface_GetCarriedObjectAttachmentInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutAttachInfo != nullptr)
		*OutAttachInfo = std::move(Parms.OutAttachInfo);
}


// Function FortniteGame.FortAIDirector.ShouldSpawnGuardians
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::ShouldSpawnGuardians()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIDirector", "ShouldSpawnGuardians");

	Params::FortAIDirector_ShouldSpawnGuardians Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.Activate
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortAIDirector::Activate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "Activate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.Deactivate
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortAIDirector::Deactivate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "Deactivate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.GetClosestRift
// (BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   TestPosition                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   MinDistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxDistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuildingRift*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingRift* AFortAIDirector::GetClosestRift(const struct FVector& TestPosition, float MinDistance, float MaxDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "GetClosestRift");

	Params::FortAIDirector_GetClosestRift Parms{};

	Parms.TestPosition = std::move(TestPosition);
	Parms.MinDistance = MinDistance;
	Parms.MaxDistance = MaxDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.GetNumPlayers
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortAIDirector::GetNumPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "GetNumPlayers");

	Params::FortAIDirector_GetNumPlayers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.OnDayPhaseChanged
// (Native, Public)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIDirector::OnDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnDayPhaseChanged");

	Params::FortAIDirector_OnDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.OnDirectorDeactivated
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortAIDirector::OnDirectorDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnDirectorDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnFadeStarted
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnFadeStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnFadeStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnPawnDied
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortAIPawn*                      KilledPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIDirector::OnPawnDied(class AFortAIPawn* KilledPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnPawnDied");

	Params::FortAIDirector_OnPawnDied Parms{};

	Parms.KilledPawn = KilledPawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIDirector.OnPeakStarted
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnPeakStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnPeakStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnPlayerDied
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIDirector::OnPlayerDied(class AFortPlayerPawn* PlayerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnPlayerDied");

	Params::FortAIDirector_OnPlayerDied Parms{};

	Parms.PlayerPawn = PlayerPawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIDirector.OnPlayerSpawn
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIDirector::OnPlayerSpawn(class AFortPlayerPawn* PlayerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnPlayerSpawn");

	Params::FortAIDirector_OnPlayerSpawn Parms{};

	Parms.PlayerPawn = PlayerPawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIDirector.OnRampStarted
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnRampStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnRampStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnReadyToSpawnGuardians
// (BlueprintAuthorityOnly, Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<class ABuildingContainer*>&BuildingContainersToGuard                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIDirector::OnReadyToSpawnGuardians(const TArray<class ABuildingContainer*>& BuildingContainersToGuard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnReadyToSpawnGuardians");

	Params::FortAIDirector_OnReadyToSpawnGuardians Parms{};

	Parms.BuildingContainersToGuard = std::move(BuildingContainersToGuard);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.OnRestStarted
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnRestStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnRestStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnStartSpawningPATrolls
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnStartSpawningPATrolls()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnStartSpawningPATrolls");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.OnStopSpawningPATrolls
// (Event, Public, BlueprintEvent)

void AFortAIDirector::OnStopSpawningPATrolls()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "OnStopSpawningPATrolls");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIDirector.PostDayPhaseChanged
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIDirector::PostDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "PostDayPhaseChanged");

	Params::FortAIDirector_PostDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIDirector.ReceivePawnSpawned
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPawn*                        SpawnedPawn                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIDirector::ReceivePawnSpawned(class AFortPawn* SpawnedPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "ReceivePawnSpawned");

	Params::FortAIDirector_ReceivePawnSpawned Parms{};

	Parms.SpawnedPawn = SpawnedPawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIDirector.RegisterPatrolWard
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TScriptInterface<class IFortPatrolWardInterface>PatrolWard                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)

void AFortAIDirector::RegisterPatrolWard(TScriptInterface<class IFortPatrolWardInterface> PatrolWard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "RegisterPatrolWard");

	Params::FortAIDirector_RegisterPatrolWard Parms{};

	Parms.PatrolWard = PatrolWard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.UnregisterPatrolWard
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TScriptInterface<class IFortPatrolWardInterface>PatrolWard                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)

void AFortAIDirector::UnregisterPatrolWard(TScriptInterface<class IFortPatrolWardInterface> PatrolWard)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "UnregisterPatrolWard");

	Params::FortAIDirector_UnregisterPatrolWard Parms{};

	Parms.PatrolWard = PatrolWard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirector.IsAnyActiveEncounterRelevantToPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerPawn*                  Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::IsAnyActiveEncounterRelevantToPlayer(class AFortPlayerPawn* Player) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "IsAnyActiveEncounterRelevantToPlayer");

	Params::FortAIDirector_IsAnyActiveEncounterRelevantToPlayer Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.IsAnyAIRelevantToPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerPawn*                  Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::IsAnyAIRelevantToPlayer(class AFortPlayerPawn* Player) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "IsAnyAIRelevantToPlayer");

	Params::FortAIDirector_IsAnyAIRelevantToPlayer Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.IsAnyEncounterGoalWithinDistanceOfPoint
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOnlyActiveEncounters                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::IsAnyEncounterGoalWithinDistanceOfPoint(const struct FVector& Point, float Distance, bool bOnlyActiveEncounters) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "IsAnyEncounterGoalWithinDistanceOfPoint");

	Params::FortAIDirector_IsAnyEncounterGoalWithinDistanceOfPoint Parms{};

	Parms.Point = std::move(Point);
	Parms.Distance = Distance;
	Parms.bOnlyActiveEncounters = bOnlyActiveEncounters;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.IsLineTooCloseToPatrolWards
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   LineStart                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   LineEnd                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::IsLineTooCloseToPatrolWards(const struct FVector& LineStart, const struct FVector& LineEnd) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "IsLineTooCloseToPatrolWards");

	Params::FortAIDirector_IsLineTooCloseToPatrolWards Parms{};

	Parms.LineStart = std::move(LineStart);
	Parms.LineEnd = std::move(LineEnd);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirector.IsPointTooCloseToPatrolWards
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Point                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const EWardAffectType                   WardEffectTypeFilter                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIDirector::IsPointTooCloseToPatrolWards(const struct FVector& Point, const EWardAffectType WardEffectTypeFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirector", "IsPointTooCloseToPatrolWards");

	Params::FortAIDirector_IsPointTooCloseToPatrolWards Parms{};

	Parms.Point = std::move(Point);
	Parms.WardEffectTypeFilter = WardEffectTypeFilter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthSet.OnRep_CurrentShield
// (Final, Native, Public)

void UFortHealthSet::OnRep_CurrentShield()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthSet", "OnRep_CurrentShield");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthSet.OnRep_Health
// (Final, Native, Public)

void UFortHealthSet::OnRep_Health()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthSet", "OnRep_Health");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthSet.OnRep_MaxHealth
// (Final, Native, Public)

void UFortHealthSet::OnRep_MaxHealth()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthSet", "OnRep_MaxHealth");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthSet.OnRep_Shield
// (Final, Native, Public)

void UFortHealthSet::OnRep_Shield()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthSet", "OnRep_Shield");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.GetGroundSpeedForUrgency
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIPawn*                      FortAIPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortMovementUrgency                    Urgency                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIPawn::GetGroundSpeedForUrgency(class AFortAIPawn* FortAIPawn, EFortMovementUrgency Urgency)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIPawn", "GetGroundSpeedForUrgency");

	Params::FortAIPawn_GetGroundSpeedForUrgency Parms{};

	Parms.FortAIPawn = FortAIPawn;
	Parms.Urgency = Urgency;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetMovementStyle
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AFortAIPawn*                FortAIPawn                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortMovementStyle                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortMovementStyle AFortAIPawn::GetMovementStyle(const class AFortAIPawn* FortAIPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIPawn", "GetMovementStyle");

	Params::FortAIPawn_GetMovementStyle Parms{};

	Parms.FortAIPawn = FortAIPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetMovementUrgency
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIPawn*                      FortAIPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortMovementUrgency                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortMovementUrgency AFortAIPawn::GetMovementUrgency(class AFortAIPawn* FortAIPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIPawn", "GetMovementUrgency");

	Params::FortAIPawn_GetMovementUrgency Parms{};

	Parms.FortAIPawn = FortAIPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.AddFortAbilitySet
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAbilitySet*                  FortAbilitySet                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::AddFortAbilitySet(class UFortAbilitySet* FortAbilitySet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "AddFortAbilitySet");

	Params::FortAIPawn_AddFortAbilitySet Parms{};

	Parms.FortAbilitySet = FortAbilitySet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.BroadcastSpawnFromRift
// (Final, Native, Public)

void AFortAIPawn::BroadcastSpawnFromRift()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "BroadcastSpawnFromRift");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.DestroyStolenItem
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::DestroyStolenItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "DestroyStolenItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.DetermineFailedToReachGoalState
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::DetermineFailedToReachGoalState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "DetermineFailedToReachGoalState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.DetermineProximateState
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::DetermineProximateState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "DetermineProximateState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.DetermineReachedGoalState
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::DetermineReachedGoalState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "DetermineReachedGoalState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.DropStolenItem
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::DropStolenItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "DropStolenItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.FailsafeKill
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::FailsafeKill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "FailsafeKill");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.FinishSpawning
// (Final, Native, Public)

void AFortAIPawn::FinishSpawning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "FinishSpawning");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.HandleFailedToReachGoalState
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     GoalActor                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::HandleFailedToReachGoalState(const class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "HandleFailedToReachGoalState");

	Params::FortAIPawn_HandleFailedToReachGoalState Parms{};

	Parms.GoalActor = GoalActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIPawn.HandleReachedGoalState
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     GoalActor                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::HandleReachedGoalState(const class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "HandleReachedGoalState");

	Params::FortAIPawn_HandleReachedGoalState Parms{};

	Parms.GoalActor = GoalActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIPawn.HasStolenItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::HasStolenItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "HasStolenItem");

	Params::FortAIPawn_HasStolenItem Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.IsValidNavigationLocation
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::IsValidNavigationLocation(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "IsValidNavigationLocation");

	Params::FortAIPawn_IsValidNavigationLocation Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.OnBeginSleepEffects
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortAIPawn::OnBeginSleepEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnBeginSleepEffects");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIPawn.OnDetermineProximateState
// (Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     GoalActor                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::OnDetermineProximateState(const class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnDetermineProximateState");

	Params::FortAIPawn_OnDetermineProximateState Parms{};

	Parms.GoalActor = GoalActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAIPawn.OnEndSleepEffects
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortAIPawn::OnEndSleepEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnEndSleepEffects");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIPawn.OnForceSpawnEffectCompletion
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortAIPawn::OnForceSpawnEffectCompletion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnForceSpawnEffectCompletion");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIPawn.OnRep_bIsSleeping
// (Final, Native, Protected)

void AFortAIPawn::OnRep_bIsSleeping()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnRep_bIsSleeping");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.OnRep_CurrentFortAILODLevel
// (Final, Native, Public)

void AFortAIPawn::OnRep_CurrentFortAILODLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnRep_CurrentFortAILODLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.OnRep_FinishSpawning
// (Final, Native, Public)

void AFortAIPawn::OnRep_FinishSpawning()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnRep_FinishSpawning");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.OnSleepingAIsFloorBuildingActorDied
// (Final, Native, Public, 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)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIPawn::OnSleepingAIsFloorBuildingActorDied(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, class AActor* DamageCauser, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& Momentum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnSleepingAIsFloorBuildingActorDied");

	Params::FortAIPawn_OnSleepingAIsFloorBuildingActorDied Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.Momentum = std::move(Momentum);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.OnSpawnedFromRift
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortAIPawn::OnSpawnedFromRift()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "OnSpawnedFromRift");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIPawn.SetAIType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortressAIType                         InAIType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::SetAIType(EFortressAIType InAIType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetAIType");

	Params::FortAIPawn_SetAIType Parms{};

	Parms.InAIType = InAIType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetEncounterInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIEncounterInfo*             InEncounterInfo                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::SetEncounterInfo(class UFortAIEncounterInfo* InEncounterInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetEncounterInfo");

	Params::FortAIPawn_SetEncounterInfo Parms{};

	Parms.InEncounterInfo = InEncounterInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetEyeColor
// (BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              NewEyeColor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   NewEyeBrightness                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::SetEyeColor(const struct FLinearColor& NewEyeColor, float NewEyeBrightness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetEyeColor");

	Params::FortAIPawn_SetEyeColor Parms{};

	Parms.NewEyeColor = std::move(NewEyeColor);
	Parms.NewEyeBrightness = NewEyeBrightness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetIsCharging
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewIsCharging                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIPawn::SetIsCharging(bool bNewIsCharging)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetIsCharging");

	Params::FortAIPawn_SetIsCharging Parms{};

	Parms.bNewIsCharging = bNewIsCharging;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetMovementUrgency
// (Native, Public, BlueprintCallable)
// Parameters:
// EFortMovementUrgency                    Urgency                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::SetMovementUrgency(EFortMovementUrgency Urgency)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetMovementUrgency");

	Params::FortAIPawn_SetMovementUrgency Parms{};

	Parms.Urgency = Urgency;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetRequiresNormalLOD
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bRequiresNormalLOD_0                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIPawn::SetRequiresNormalLOD(bool bRequiresNormalLOD_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetRequiresNormalLOD");

	Params::FortAIPawn_SetRequiresNormalLOD Parms{};

	Parms.bRequiresNormalLOD_0 = bRequiresNormalLOD_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.SetSkinColor
// (BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              NewSkinColor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   NewSkinBrightness                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIPawn::SetSkinColor(const struct FLinearColor& NewSkinColor, float NewSkinBrightness)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "SetSkinColor");

	Params::FortAIPawn_SetSkinColor Parms{};

	Parms.NewSkinColor = std::move(NewSkinColor);
	Parms.NewSkinBrightness = NewSkinBrightness;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.StartMovingAndThinking
// (Final, Native, Public)

void AFortAIPawn::StartMovingAndThinking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "StartMovingAndThinking");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.TurnOnSleepingOptimizations
// (Final, Native, Public, BlueprintCallable)

void AFortAIPawn::TurnOnSleepingOptimizations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "TurnOnSleepingOptimizations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIPawn.CanOpenDoors
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::CanOpenDoors() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "CanOpenDoors");

	Params::FortAIPawn_CanOpenDoors Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetImpactPhysicalSurfaceEffect
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FHitResult&                Impact                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UParticleSystem*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UParticleSystem* AFortAIPawn::GetImpactPhysicalSurfaceEffect(const struct FHitResult& Impact) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetImpactPhysicalSurfaceEffect");

	Params::FortAIPawn_GetImpactPhysicalSurfaceEffect Parms{};

	Parms.Impact = std::move(Impact);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetImpactPhysicalSurfaceSound
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FHitResult&                Impact                                                 (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class USoundBase*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USoundBase* AFortAIPawn::GetImpactPhysicalSurfaceSound(const struct FHitResult& Impact) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetImpactPhysicalSurfaceSound");

	Params::FortAIPawn_GetImpactPhysicalSurfaceSound Parms{};

	Parms.Impact = std::move(Impact);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetLocalWildcardAsFloat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortLocalWildcardData&    Data                                                   (Parm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIPawn::GetLocalWildcardAsFloat(const struct FFortLocalWildcardData& Data) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetLocalWildcardAsFloat");

	Params::FortAIPawn_GetLocalWildcardAsFloat Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetLocalWildcardAsInt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortLocalWildcardData&    Data                                                   (Parm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortAIPawn::GetLocalWildcardAsInt(const struct FFortLocalWildcardData& Data) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetLocalWildcardAsInt");

	Params::FortAIPawn_GetLocalWildcardAsInt Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetProximityNotifyDistXY
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIPawn::GetProximityNotifyDistXY() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetProximityNotifyDistXY");

	Params::FortAIPawn_GetProximityNotifyDistXY Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetSpawnLocation
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortAIPawn::GetSpawnLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetSpawnLocation");

	Params::FortAIPawn_GetSpawnLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetSpawnRotation
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AFortAIPawn::GetSpawnRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetSpawnRotation");

	Params::FortAIPawn_GetSpawnRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetTimeSinceLastHit
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIPawn::GetTimeSinceLastHit() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetTimeSinceLastHit");

	Params::FortAIPawn_GetTimeSinceLastHit Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetWildcardDataAsFloat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortWildcardData&         Data                                                   (Parm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIPawn::GetWildcardDataAsFloat(const struct FFortWildcardData& Data) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetWildcardDataAsFloat");

	Params::FortAIPawn_GetWildcardDataAsFloat Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.GetWildcardDataAsInt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortWildcardData&         Data                                                   (Parm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortAIPawn::GetWildcardDataAsInt(const struct FFortWildcardData& Data) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "GetWildcardDataAsInt");

	Params::FortAIPawn_GetWildcardDataAsInt Parms{};

	Parms.Data = std::move(Data);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.ShouldPauseAfterMelee
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::ShouldPauseAfterMelee() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "ShouldPauseAfterMelee");

	Params::FortAIPawn_ShouldPauseAfterMelee Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.ShouldPerformMeleeLungeAttacks
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::ShouldPerformMeleeLungeAttacks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "ShouldPerformMeleeLungeAttacks");

	Params::FortAIPawn_ShouldPerformMeleeLungeAttacks Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIPawn.ShouldStopOnMelee
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIPawn::ShouldStopOnMelee() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIPawn", "ShouldStopOnMelee");

	Params::FortAIPawn_ShouldStopOnMelee Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetHealthRegenDelayGameplayEffect
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGameplayEffect*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayEffect* IFortHealthRegenInterface::GetHealthRegenDelayGameplayEffect() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetHealthRegenDelayGameplayEffect");

	Params::FortHealthRegenInterface_GetHealthRegenDelayGameplayEffect Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetHealthRegenGameplayEffect
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGameplayEffect*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayEffect* IFortHealthRegenInterface::GetHealthRegenGameplayEffect() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetHealthRegenGameplayEffect");

	Params::FortHealthRegenInterface_GetHealthRegenGameplayEffect Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetHealthRegenGameplayEffectClass
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UGameplayEffect>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UGameplayEffect> IFortHealthRegenInterface::GetHealthRegenGameplayEffectClass() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetHealthRegenGameplayEffectClass");

	Params::FortHealthRegenInterface_GetHealthRegenGameplayEffectClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetShieldRegenDelayGameplayEffect
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGameplayEffect*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayEffect* IFortHealthRegenInterface::GetShieldRegenDelayGameplayEffect() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetShieldRegenDelayGameplayEffect");

	Params::FortHealthRegenInterface_GetShieldRegenDelayGameplayEffect Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetShieldRegenGameplayEffect
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGameplayEffect*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayEffect* IFortHealthRegenInterface::GetShieldRegenGameplayEffect() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetShieldRegenGameplayEffect");

	Params::FortHealthRegenInterface_GetShieldRegenGameplayEffect Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortHealthRegenInterface.GetShieldRegenGameplayEffectClass
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UGameplayEffect>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UGameplayEffect> IFortHealthRegenInterface::GetShieldRegenGameplayEffectClass() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthRegenInterface", "GetShieldRegenGameplayEffectClass");

	Params::FortHealthRegenInterface_GetShieldRegenGameplayEffectClass Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.CanPredictJumpApex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerPawn::CanPredictJumpApex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "CanPredictJumpApex");

	Params::FortPlayerPawn_CanPredictJumpApex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.ClientNotifyAbilityFailed
// (Net, Native, Event, Public, NetClient)
// Parameters:
// const class UGameplayAbility*           FailedAbility                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     FailedReason                                           (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ClientNotifyAbilityFailed(const class UGameplayAbility* FailedAbility, const struct FGameplayTagContainer& FailedReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ClientNotifyAbilityFailed");

	Params::FortPlayerPawn_ClientNotifyAbilityFailed Parms{};

	Parms.FailedAbility = FailedAbility;
	Parms.FailedReason = std::move(FailedReason);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.CycleNextOutfit
// (Final, Exec, Native, Private)

void AFortPlayerPawn::CycleNextOutfit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "CycleNextOutfit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.CyclePreviousOutfit
// (Final, Exec, Native, Private)

void AFortPlayerPawn::CyclePreviousOutfit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "CyclePreviousOutfit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.GetNavLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortPlayerPawn::GetNavLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetNavLocation");

	Params::FortPlayerPawn_GetNavLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.HandleInStasis
// (Final, Native, Public)

void AFortPlayerPawn::HandleInStasis()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "HandleInStasis");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.InternalServerSetTargeting
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// bool                                    bNewTargeting                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::InternalServerSetTargeting(bool bNewTargeting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "InternalServerSetTargeting");

	Params::FortPlayerPawn_InternalServerSetTargeting Parms{};

	Parms.bNewTargeting = bNewTargeting;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.OnCharacterPartsReinitialized
// (Event, Protected, BlueprintEvent)

void AFortPlayerPawn::OnCharacterPartsReinitialized()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "OnCharacterPartsReinitialized");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPlayerPawn.OnCoolDownEnded
// (Event, Public, BlueprintEvent)

void AFortPlayerPawn::OnCoolDownEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "OnCoolDownEnded");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPlayerPawn.OnCoolDownStarted
// (Event, Public, BlueprintEvent)

void AFortPlayerPawn::OnCoolDownStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "OnCoolDownStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPlayerPawn.OnRep_CharPartAnimMontageInfo
// (Final, Native, Private)

void AFortPlayerPawn::OnRep_CharPartAnimMontageInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "OnRep_CharPartAnimMontageInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.RandomizeCharacter
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    GenderString                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::RandomizeCharacter(const class FString& GenderString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "RandomizeCharacter");

	Params::FortPlayerPawn_RandomizeCharacter Parms{};

	Parms.GenderString = std::move(GenderString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.RandomizeOutfit
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    GenderString                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::RandomizeOutfit(const class FString& GenderString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "RandomizeOutfit");

	Params::FortPlayerPawn_RandomizeOutfit Parms{};

	Parms.GenderString = std::move(GenderString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerChooseGender
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortCustomGender                       Gender                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerChooseGender(EFortCustomGender Gender)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerChooseGender");

	Params::FortPlayerPawn_ServerChooseGender Parms{};

	Parms.Gender = Gender;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerChoosePart
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCustomCharacterPart*             ChosenCharacterPart                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerChoosePart(EFortCustomPartType Part, class UCustomCharacterPart* ChosenCharacterPart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerChoosePart");

	Params::FortPlayerPawn_ServerChoosePart Parms{};

	Parms.Part = Part;
	Parms.ChosenCharacterPart = ChosenCharacterPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerCycleAccessoryColorSwatch
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNext                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerCycleAccessoryColorSwatch(EFortCustomPartType Part, bool bNext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerCycleAccessoryColorSwatch");

	Params::FortPlayerPawn_ServerCycleAccessoryColorSwatch Parms{};

	Parms.Part = Part;
	Parms.bNext = bNext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerCycleColorSwatch
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EColorSwatchType                        SwatchType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNext                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerCycleColorSwatch(EColorSwatchType SwatchType, bool bNext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerCycleColorSwatch");

	Params::FortPlayerPawn_ServerCycleColorSwatch Parms{};

	Parms.SwatchType = SwatchType;
	Parms.bNext = bNext;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerCycleOutfit
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                                    bNextOutfit                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerCycleOutfit(bool bNextOutfit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerCycleOutfit");

	Params::FortPlayerPawn_ServerCycleOutfit Parms{};

	Parms.bNextOutfit = bNextOutfit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerCyclePart
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNextPart                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerCyclePart(EFortCustomPartType Part, bool bNextPart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerCyclePart");

	Params::FortPlayerPawn_ServerCyclePart Parms{};

	Parms.Part = Part;
	Parms.bNextPart = bNextPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerHandlePickup
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// class AFortPickup*                      Pickup                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InFlyTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InStartDirection                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bPlayPickupSound                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerHandlePickup(class AFortPickup* Pickup, float InFlyTime, const struct FVector& InStartDirection, bool bPlayPickupSound)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerHandlePickup");

	Params::FortPlayerPawn_ServerHandlePickup Parms{};

	Parms.Pickup = Pickup;
	Parms.InFlyTime = InFlyTime;
	Parms.InStartDirection = std::move(InStartDirection);
	Parms.bPlayPickupSound = bPlayPickupSound;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerPlayDeniedByCoolDown
// (Net, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerPawn::ServerPlayDeniedByCoolDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerPlayDeniedByCoolDown");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerRootMotionInterruptNotifyStopMontage
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class UAnimMontage*                     MontageToStop                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ServerRootMotionInterruptNotifyStopMontage(class UAnimMontage* MontageToStop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerRootMotionInterruptNotifyStopMontage");

	Params::FortPlayerPawn_ServerRootMotionInterruptNotifyStopMontage Parms{};

	Parms.MontageToStop = MontageToStop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerToggleBodyType
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerPawn::ServerToggleBodyType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerToggleBodyType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ServerToggleGender
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerPawn::ServerToggleGender()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ServerToggleGender");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.SetFirstPersonCamera
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bNewUseFirstPersonCamera                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SetFirstPersonCamera(bool bNewUseFirstPersonCamera)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SetFirstPersonCamera");

	Params::FortPlayerPawn_SetFirstPersonCamera Parms{};

	Parms.bNewUseFirstPersonCamera = bNewUseFirstPersonCamera;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPlayerPawn.SetHomeActor
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NewActor                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SetHomeActor(class AActor* NewActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SetHomeActor");

	Params::FortPlayerPawn_SetHomeActor Parms{};

	Parms.NewActor = NewActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.SetVectorParameterValueForAllCharacterParts
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class FName                             ParameterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SetVectorParameterValueForAllCharacterParts(class FName ParameterName, const struct FLinearColor& Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SetVectorParameterValueForAllCharacterParts");

	Params::FortPlayerPawn_SetVectorParameterValueForAllCharacterParts Parms{};

	Parms.ParameterName = ParameterName;
	Parms.Value = std::move(Value);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.SetVectorParameterValueForBodyParts
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class FName                             ParameterName                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SetVectorParameterValueForBodyParts(class FName ParameterName, const struct FLinearColor& Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SetVectorParameterValueForBodyParts");

	Params::FortPlayerPawn_SetVectorParameterValueForBodyParts Parms{};

	Parms.ParameterName = ParameterName;
	Parms.Value = std::move(Value);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.SwitchToNextPart
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    PartName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SwitchToNextPart(const class FString& PartName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SwitchToNextPart");

	Params::FortPlayerPawn_SwitchToNextPart Parms{};

	Parms.PartName = std::move(PartName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.SwitchToPreviousPart
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    PartName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::SwitchToPreviousPart(const class FString& PartName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "SwitchToPreviousPart");

	Params::FortPlayerPawn_SwitchToPreviousPart Parms{};

	Parms.PartName = std::move(PartName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ToggleBodyType
// (Final, Exec, Native, Public)

void AFortPlayerPawn::ToggleBodyType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ToggleBodyType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.ToggleGender
// (Final, Exec, Native, Public)

void AFortPlayerPawn::ToggleGender()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ToggleGender");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.DefaultTimeToJumpApex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::DefaultTimeToJumpApex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "DefaultTimeToJumpApex");

	Params::FortPlayerPawn_DefaultTimeToJumpApex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetCharacterBodyType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomBodyType                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortCustomBodyType AFortPlayerPawn::GetCharacterBodyType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetCharacterBodyType");

	Params::FortPlayerPawn_GetCharacterBodyType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetCharacterGender
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomGender                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortCustomGender AFortPlayerPawn::GetCharacterGender() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetCharacterGender");

	Params::FortPlayerPawn_GetCharacterGender Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetGender
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   IsMale                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   IsFemale                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerPawn::GetGender(bool* IsMale, bool* IsFemale) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetGender");

	Params::FortPlayerPawn_GetGender Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (IsMale != nullptr)
		*IsMale = Parms.IsMale;

	if (IsFemale != nullptr)
		*IsFemale = Parms.IsFemale;
}


// Function FortniteGame.FortPlayerPawn.GetHomeActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortPlayerPawn::GetHomeActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetHomeActor");

	Params::FortPlayerPawn_GetHomeActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetJumpZ
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::GetJumpZ() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetJumpZ");

	Params::FortPlayerPawn_GetJumpZ Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetMaxStamina
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::GetMaxStamina() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetMaxStamina");

	Params::FortPlayerPawn_GetMaxStamina Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetPercentageOutfitComplete
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::GetPercentageOutfitComplete(EFortCustomPartType Part) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetPercentageOutfitComplete");

	Params::FortPlayerPawn_GetPercentageOutfitComplete Parms{};

	Parms.Part = Part;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetSkeletalMeshForPartType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomPartType                     PartType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* AFortPlayerPawn::GetSkeletalMeshForPartType(EFortCustomPartType PartType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetSkeletalMeshForPartType");

	Params::FortPlayerPawn_GetSkeletalMeshForPartType Parms{};

	Parms.PartType = PartType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.GetStamina
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::GetStamina() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "GetStamina");

	Params::FortPlayerPawn_GetStamina Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.IsSprinting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerPawn::IsSprinting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "IsSprinting");

	Params::FortPlayerPawn_IsSprinting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.ListCharacterParts
// (Final, Exec, Native, Private, Const)
// Parameters:
// const class FString&                    GenderAndOrPartString                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerPawn::ListCharacterParts(const class FString& GenderAndOrPartString) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "ListCharacterParts");

	Params::FortPlayerPawn_ListCharacterParts Parms{};

	Parms.GenderAndOrPartString = std::move(GenderAndOrPartString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerPawn.PartOutfitIsComplete
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerPawn::PartOutfitIsComplete(EFortCustomPartType Part) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "PartOutfitIsComplete");

	Params::FortPlayerPawn_PartOutfitIsComplete Parms{};

	Parms.Part = Part;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerPawn.TimeFromJumpApex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerPawn::TimeFromJumpApex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerPawn", "TimeFromJumpApex");

	Params::FortPlayerPawn_TimeFromJumpApex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerState.GetCurrentPawn
// (Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerPawn*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerPawn* AFortPlayerState::GetCurrentPawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "GetCurrentPawn");

	Params::FortPlayerState_GetCurrentPawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerState.OnRep_AccessoryColorSwatches
// (Final, Native, Protected)

void AFortPlayerState::OnRep_AccessoryColorSwatches()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_AccessoryColorSwatches");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_CharacterColorSwatches
// (Final, Native, Protected)

void AFortPlayerState::OnRep_CharacterColorSwatches()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_CharacterColorSwatches");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_CharacterParts
// (Final, Native, Protected)

void AFortPlayerState::OnRep_CharacterParts()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_CharacterParts");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_CurrentCharXP
// (Final, Native, Protected)

void AFortPlayerState::OnRep_CurrentCharXP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_CurrentCharXP");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_HeroID
// (Final, Native, Protected)

void AFortPlayerState::OnRep_HeroID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_HeroID");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_HeroType
// (Final, Native, Protected)

void AFortPlayerState::OnRep_HeroType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_HeroType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_HomeActor
// (Native, Protected)
// Parameters:
// class AActor*                           OldHomeActor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerState::OnRep_HomeActor(class AActor* OldHomeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_HomeActor");

	Params::FortPlayerState_OnRep_HomeActor Parms{};

	Parms.OldHomeActor = OldHomeActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_PartyOwner
// (Final, Native, Protected)

void AFortPlayerState::OnRep_PartyOwner()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_PartyOwner");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_PlayerName
// (Native, Protected)

void AFortPlayerState::OnRep_PlayerName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_PlayerName");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_PlayerTeam
// (Native, Protected)

void AFortPlayerState::OnRep_PlayerTeam()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_PlayerTeam");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_ScoreStatChanged
// (Native, Protected)

void AFortPlayerState::OnRep_ScoreStatChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_ScoreStatChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.OnRep_SessionOwner
// (Final, Native, Protected)

void AFortPlayerState::OnRep_SessionOwner()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "OnRep_SessionOwner");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerState.GetPlayerAttributesProxyActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerAttributesProxyActor*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerAttributesProxyActor* AFortPlayerState::GetPlayerAttributesProxyActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "GetPlayerAttributesProxyActor");

	Params::FortPlayerState_GetPlayerAttributesProxyActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerState.GetUniqueID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FUniqueNetIdRepl                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FUniqueNetIdRepl AFortPlayerState::GetUniqueID() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerState", "GetUniqueID");

	Params::FortPlayerState_GetUniqueID Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownManager.RegisterSlotCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   MapSlotId                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCameraComponent*                 InCameraComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UMyTownManager::RegisterSlotCamera(int32 MapSlotId, class UCameraComponent* InCameraComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownManager", "RegisterSlotCamera");

	Params::MyTownManager_RegisterSlotCamera Parms{};

	Parms.MapSlotId = MapSlotId;
	Parms.InCameraComponent = InCameraComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.GetStaticSetBonusData
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayTag&              InSetBonusTag                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const EFortBrushSize                    InBrushSize                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutRequiredWorkersCount                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutSetBonusName                                        (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FSlateBrush*                     OutBrush                                               (Parm, OutParm, NativeAccessSpecifierPublic)

void UHomeBaseContext::GetStaticSetBonusData(const struct FGameplayTag& InSetBonusTag, const EFortBrushSize InBrushSize, int32* OutRequiredWorkersCount, class FText* OutSetBonusName, struct FSlateBrush* OutBrush)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HomeBaseContext", "GetStaticSetBonusData");

	Params::HomeBaseContext_GetStaticSetBonusData Parms{};

	Parms.InSetBonusTag = std::move(InSetBonusTag);
	Parms.InBrushSize = InBrushSize;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRequiredWorkersCount != nullptr)
		*OutRequiredWorkersCount = Parms.OutRequiredWorkersCount;

	if (OutSetBonusName != nullptr)
		*OutSetBonusName = std::move(Parms.OutSetBonusName);

	if (OutBrush != nullptr)
		*OutBrush = std::move(Parms.OutBrush);
}


// Function FortniteGame.HomeBaseContext.AutoSlotAllWorkers
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::AutoSlotAllWorkers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "AutoSlotAllWorkers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.BeginWorkerPreview
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UFortWorker*                WorkerItem                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UHomeBaseMainBuilding*      BuildingToOccupy                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             WorkerSlotToOccupy                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHomeBaseContext::BeginWorkerPreview(const class UFortWorker* WorkerItem, const class UHomeBaseMainBuilding* BuildingToOccupy, const int32 WorkerSlotToOccupy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "BeginWorkerPreview");

	Params::HomeBaseContext_BeginWorkerPreview Parms{};

	Parms.WorkerItem = WorkerItem;
	Parms.BuildingToOccupy = BuildingToOccupy;
	Parms.WorkerSlotToOccupy = WorkerSlotToOccupy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.EndWorkerPreview
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::EndWorkerPreview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "EndWorkerPreview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.GetWorkerRatingAtLevelForBuilding
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UFortWorker*                WorkerItem                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             WorkerLevel                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UHomeBaseMainBuilding*      Building                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UHomeBaseContext::GetWorkerRatingAtLevelForBuilding(const class UFortWorker* WorkerItem, const int32 WorkerLevel, const class UHomeBaseMainBuilding* Building)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetWorkerRatingAtLevelForBuilding");

	Params::HomeBaseContext_GetWorkerRatingAtLevelForBuilding Parms{};

	Parms.WorkerItem = WorkerItem;
	Parms.WorkerLevel = WorkerLevel;
	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.RequestCloseBuildingPanel
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::RequestCloseBuildingPanel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "RequestCloseBuildingPanel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.RequestCloseOverview
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::RequestCloseOverview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "RequestCloseOverview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.RequestOpenBuildingPanel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UHomeBaseMainBuilding*      Building                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHomeBaseContext::RequestOpenBuildingPanel(const class UHomeBaseMainBuilding* Building)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "RequestOpenBuildingPanel");

	Params::HomeBaseContext_RequestOpenBuildingPanel Parms{};

	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.RequestOpenOverview
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::RequestOpenOverview()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "RequestOpenOverview");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.ShouldShowBang
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UHomeBaseBuilding*          Building                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UHomeBaseContext::ShouldShowBang(const class UHomeBaseBuilding* Building)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "ShouldShowBang");

	Params::HomeBaseContext_ShouldShowBang Parms{};

	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.UnslotAllWorkers
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseContext::UnslotAllWorkers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "UnslotAllWorkers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.GetAccountLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UHomeBaseContext::GetAccountLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetAccountLevel");

	Params::HomeBaseContext_GetAccountLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetAllBuildings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UHomeBaseMainBuilding*>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UHomeBaseMainBuilding*> UHomeBaseContext::GetAllBuildings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetAllBuildings");

	Params::HomeBaseContext_GetAllBuildings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetBuilding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    TemplateId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UHomeBaseMainBuilding*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UHomeBaseMainBuilding* UHomeBaseContext::GetBuilding(const class FString& TemplateId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetBuilding");

	Params::HomeBaseContext_GetBuilding Parms{};

	Parms.TemplateId = std::move(TemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetBuildingBonusDescriptionsForSetBonus
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              SetBonusTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FSingleBuildingBonusDescription>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FSingleBuildingBonusDescription> UHomeBaseContext::GetBuildingBonusDescriptionsForSetBonus(const struct FGameplayTag& SetBonusTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetBuildingBonusDescriptionsForSetBonus");

	Params::HomeBaseContext_GetBuildingBonusDescriptionsForSetBonus Parms{};

	Parms.SetBonusTag = std::move(SetBonusTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetBuildingTemplateIdFromInstanceId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    InstanceId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UHomeBaseContext::GetBuildingTemplateIdFromInstanceId(const class FString& InstanceId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetBuildingTemplateIdFromInstanceId");

	Params::HomeBaseContext_GetBuildingTemplateIdFromInstanceId Parms{};

	Parms.InstanceId = std::move(InstanceId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetHomeBaseData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMyTownData*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMyTownData* UHomeBaseContext::GetHomeBaseData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetHomeBaseData");

	Params::HomeBaseContext_GetHomeBaseData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetWorkerPreviewStatus
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool*                                   OutIsPreviewing                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortWorker**                     OutWorker                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutMatchesPersonality                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   OutMatchesBuildingType                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FWorkerSetBonusState*            OutSetBonusState                                       (Parm, OutParm, NativeAccessSpecifierPublic)

void UHomeBaseContext::GetWorkerPreviewStatus(bool* OutIsPreviewing, class UFortWorker** OutWorker, bool* OutMatchesPersonality, bool* OutMatchesBuildingType, struct FWorkerSetBonusState* OutSetBonusState) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetWorkerPreviewStatus");

	Params::HomeBaseContext_GetWorkerPreviewStatus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutIsPreviewing != nullptr)
		*OutIsPreviewing = Parms.OutIsPreviewing;

	if (OutWorker != nullptr)
		*OutWorker = Parms.OutWorker;

	if (OutMatchesPersonality != nullptr)
		*OutMatchesPersonality = Parms.OutMatchesPersonality;

	if (OutMatchesBuildingType != nullptr)
		*OutMatchesBuildingType = Parms.OutMatchesBuildingType;

	if (OutSetBonusState != nullptr)
		*OutSetBonusState = std::move(Parms.OutSetBonusState);
}


// Function FortniteGame.HomeBaseContext.GetWorkerSetBonusStates
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<class UFortWorker*>&       Workers                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FWorkerSetBonusState>     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FWorkerSetBonusState> UHomeBaseContext::GetWorkerSetBonusStates(const TArray<class UFortWorker*>& Workers) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetWorkerSetBonusStates");

	Params::HomeBaseContext_GetWorkerSetBonusStates Parms{};

	Parms.Workers = std::move(Workers);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.GetWorkerSlottingPreviewState
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorker**                     OutWorkerItem                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UHomeBaseMainBuilding**           OutHostBuilding                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutSlotIndex                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHomeBaseContext::GetWorkerSlottingPreviewState(class UFortWorker** OutWorkerItem, class UHomeBaseMainBuilding** OutHostBuilding, int32* OutSlotIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "GetWorkerSlottingPreviewState");

	Params::HomeBaseContext_GetWorkerSlottingPreviewState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorkerItem != nullptr)
		*OutWorkerItem = Parms.OutWorkerItem;

	if (OutHostBuilding != nullptr)
		*OutHostBuilding = Parms.OutHostBuilding;

	if (OutSlotIndex != nullptr)
		*OutSlotIndex = Parms.OutSlotIndex;
}


// Function FortniteGame.HomeBaseContext.IsBuildingPanelOpen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UHomeBaseContext::IsBuildingPanelOpen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "IsBuildingPanelOpen");

	Params::HomeBaseContext_IsBuildingPanelOpen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.IsPreviewingWorkerSlotting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UHomeBaseContext::IsPreviewingWorkerSlotting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "IsPreviewingWorkerSlotting");

	Params::HomeBaseContext_IsPreviewingWorkerSlotting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseContext.NotifyBuildingPanelClosed
// (Final, Native, Public, BlueprintCallable, Const)

void UHomeBaseContext::NotifyBuildingPanelClosed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "NotifyBuildingPanelClosed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseContext.NotifyBuildingPanelOpened
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class UHomeBaseMainBuilding*      Building                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHomeBaseContext::NotifyBuildingPanelOpened(const class UHomeBaseMainBuilding* Building) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseContext", "NotifyBuildingPanelOpened");

	Params::HomeBaseContext_NotifyBuildingPanelOpened Parms{};

	Parms.Building = Building;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BlueprintContextLibrary.GetContext
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          ContextObject                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UBlueprintContextBase>Class_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBlueprintContextBase*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBlueprintContextBase* UBlueprintContextLibrary::GetContext(class UObject* ContextObject, TSubclassOf<class UBlueprintContextBase> Class_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("BlueprintContextLibrary", "GetContext");

	Params::BlueprintContextLibrary_GetContext Parms{};

	Parms.ContextObject = ContextObject;
	Parms.Class_0 = Class_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpawnableByPlacementSystemInterface.GetMission
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortMission*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortMission* IFortSpawnableByPlacementSystemInterface::GetMission() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpawnableByPlacementSystemInterface", "GetMission");

	Params::FortSpawnableByPlacementSystemInterface_GetMission Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSpawnableByPlacementSystemInterface.GetMissionGuid
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGuid                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FGuid IFortSpawnableByPlacementSystemInterface::GetMissionGuid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSpawnableByPlacementSystemInterface", "GetMissionGuid");

	Params::FortSpawnableByPlacementSystemInterface_GetMissionGuid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.BlueprintOnBeginInteract
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingActor::BlueprintOnBeginInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "BlueprintOnBeginInteract");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingActor.BlueprintOnInteract
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingActor::BlueprintOnInteract(const class AFortPawn* InteractingPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "BlueprintOnInteract");

	Params::BuildingActor_BlueprintOnInteract Parms{};

	Parms.InteractingPawn = InteractingPawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingActor.CustomStateChanged
// (Event, Public, BlueprintEvent)

void ABuildingActor::CustomStateChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "CustomStateChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingActor.GameplayCue_Damage
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::GameplayCue_Damage(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GameplayCue_Damage");

	Params::BuildingActor_GameplayCue_Damage Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.GameplayCue_Healing
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::GameplayCue_Healing(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GameplayCue_Healing");

	Params::BuildingActor_GameplayCue_Healing Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.GameplayCue_InstantDeath
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::GameplayCue_InstantDeath(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GameplayCue_InstantDeath");

	Params::BuildingActor_GameplayCue_InstantDeath Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.HandleDestroyed
// (Native, Protected)

void ABuildingActor::HandleDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "HandleDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.InitializeKismetSpawnedBuildingActor
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   BuildingOwner                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpawningController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingActor::InitializeKismetSpawnedBuildingActor(class ABuildingActor* BuildingOwner, class AFortPlayerController* SpawningController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "InitializeKismetSpawnedBuildingActor");

	Params::BuildingActor_InitializeKismetSpawnedBuildingActor Parms{};

	Parms.BuildingOwner = BuildingOwner;
	Parms.SpawningController = SpawningController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.OnBuildingActorInitialized
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// EFortBuildingInitializationReason       InitializationReason                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingPersistentState            BuildingPersistentState                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingActor::OnBuildingActorInitialized(EFortBuildingInitializationReason InitializationReason, EFortBuildingPersistentState BuildingPersistentState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnBuildingActorInitialized");

	Params::BuildingActor_OnBuildingActorInitialized Parms{};

	Parms.InitializationReason = InitializationReason;
	Parms.BuildingPersistentState = BuildingPersistentState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.OnDamagePlayEffects
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::OnDamagePlayEffects(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AFortPawn* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnDamagePlayEffects");

	Params::BuildingActor_OnDamagePlayEffects Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingActor.OnDamageServer
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::OnDamageServer(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnDamageServer");

	Params::BuildingActor_OnDamageServer Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingActor.OnDayPhaseChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingActor::OnDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnDayPhaseChanged");

	Params::BuildingActor_OnDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.OnDeathPlayEffects
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::OnDeathPlayEffects(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AFortPawn* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnDeathPlayEffects");

	Params::BuildingActor_OnDeathPlayEffects Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingActor.OnDeathServer
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     DamageTags                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitInfo                                                (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)

void ABuildingActor::OnDeathServer(float Damage, const struct FGameplayTagContainer& DamageTags, const struct FVector& Momentum, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser, const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnDeathServer");

	Params::BuildingActor_OnDeathServer Parms{};

	Parms.Damage = Damage;
	Parms.DamageTags = std::move(DamageTags);
	Parms.Momentum = std::move(Momentum);
	Parms.HitInfo = std::move(HitInfo);
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.EffectContext = std::move(EffectContext);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingActor.OnMatchStarted
// (Event, Public, BlueprintEvent)

void ABuildingActor::OnMatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnMatchStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingActor.OnRep_CurrentBuildingLevel
// (Native, Protected)

void ABuildingActor::OnRep_CurrentBuildingLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnRep_CurrentBuildingLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.OnRep_CustomState
// (Native, Protected)

void ABuildingActor::OnRep_CustomState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnRep_CustomState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.OnWorldReady
// (Event, Public, BlueprintEvent)

void ABuildingActor::OnWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "OnWorldReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingActor.PlacedByPlacementTool
// (Native, Event, Public, BlueprintEvent)

void ABuildingActor::PlacedByPlacementTool()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "PlacedByPlacementTool");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.SetCanExportNavigationObstacle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InCanExportNavigationObstacle                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingActor::SetCanExportNavigationObstacle(bool InCanExportNavigationObstacle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "SetCanExportNavigationObstacle");

	Params::BuildingActor_SetCanExportNavigationObstacle Parms{};

	Parms.InCanExportNavigationObstacle = InCanExportNavigationObstacle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.SetCustomState
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    NewState                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingActor::SetCustomState(const class FString& NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "SetCustomState");

	Params::BuildingActor_SetCustomState Parms{};

	Parms.NewState = std::move(NewState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.SetNavigationModifier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnableModifier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingActor::SetNavigationModifier(bool bEnableModifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "SetNavigationModifier");

	Params::BuildingActor_SetNavigationModifier Parms{};

	Parms.bEnableModifier = bEnableModifier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.ShouldDie
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::ShouldDie(float Damage, class AController* EventInstigator, class AActor* DamageCauser)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "ShouldDie");

	Params::BuildingActor_ShouldDie Parms{};

	Parms.Damage = Damage;
	Parms.EventInstigator = EventInstigator;
	Parms.DamageCauser = DamageCauser;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.SilentDie
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void ABuildingActor::SilentDie()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "SilentDie");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingActor.BlueprintCanInteract
// (Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::BlueprintCanInteract(const class AFortPawn* InteractingPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "BlueprintCanInteract");

	Params::BuildingActor_BlueprintCanInteract Parms{};

	Parms.InteractingPawn = InteractingPawn;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.BlueprintGetFailedInteractionString
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText ABuildingActor::BlueprintGetFailedInteractionString(const class AFortPawn* InteractingPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "BlueprintGetFailedInteractionString");

	Params::BuildingActor_BlueprintGetFailedInteractionString Parms{};

	Parms.InteractingPawn = InteractingPawn;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.BlueprintGetInteractionString
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText ABuildingActor::BlueprintGetInteractionString(const class AFortPawn* InteractingPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "BlueprintGetInteractionString");

	Params::BuildingActor_BlueprintGetInteractionString Parms{};

	Parms.InteractingPawn = InteractingPawn;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetCentroid
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector ABuildingActor::GetCentroid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetCentroid");

	Params::BuildingActor_GetCentroid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetCurrentBuildingLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingActor::GetCurrentBuildingLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetCurrentBuildingLevel");

	Params::BuildingActor_GetCurrentBuildingLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetCustomState
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ABuildingActor::GetCustomState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetCustomState");

	Params::BuildingActor_GetCustomState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingActor::GetHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetHealth");

	Params::BuildingActor_GetHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetHealthPercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingActor::GetHealthPercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetHealthPercent");

	Params::BuildingActor_GetHealthPercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetMaxHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingActor::GetMaxHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetMaxHealth");

	Params::BuildingActor_GetMaxHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetMissingHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingActor::GetMissingHealth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetMissingHealth");

	Params::BuildingActor_GetMissingHealth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetOwningController
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AController*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AController* ABuildingActor::GetOwningController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetOwningController");

	Params::BuildingActor_GetOwningController Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.GetOwningPlayerState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerState*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerState* ABuildingActor::GetOwningPlayerState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "GetOwningPlayerState");

	Params::BuildingActor_GetOwningPlayerState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.HasHealthLeft
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::HasHealthLeft() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "HasHealthLeft");

	Params::BuildingActor_HasHealthLeft Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.IsAcceptablePositionForPlacement
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   InLocation                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  InRotation                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortDecoTool*                    DecoTool                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsCDO                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class FText*                            OutFailureReason                                       (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::IsAcceptablePositionForPlacement(const struct FVector& InLocation, const struct FRotator& InRotation, class AFortDecoTool* DecoTool, bool bIsCDO, class FText* OutFailureReason) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "IsAcceptablePositionForPlacement");

	Params::BuildingActor_IsAcceptablePositionForPlacement Parms{};

	Parms.InLocation = std::move(InLocation);
	Parms.InRotation = std::move(InRotation);
	Parms.DecoTool = DecoTool;
	Parms.bIsCDO = bIsCDO;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutFailureReason != nullptr)
		*OutFailureReason = std::move(Parms.OutFailureReason);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.IsDamaged
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::IsDamaged() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "IsDamaged");

	Params::BuildingActor_IsDamaged Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.IsPlayerBuilt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::IsPlayerBuilt() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "IsPlayerBuilt");

	Params::BuildingActor_IsPlayerBuilt Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingActor.UseDefaultHealthBar
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingActor::UseDefaultHealthBar() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingActor", "UseDefaultHealthBar");

	Params::BuildingActor_UseDefaultHealthBar Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterRiftManager.GetAssociatedMission
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortMission*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortMission* UFortAIEncounterRiftManager::GetAssociatedMission() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterRiftManager", "GetAssociatedMission");

	Params::FortAIEncounterRiftManager_GetAssociatedMission Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingGameplayActor.DisableAbilityDeliveryInfo
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              BucketTag                                              (Parm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::DisableAbilityDeliveryInfo(const struct FGameplayTag& BucketTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "DisableAbilityDeliveryInfo");

	Params::BuildingGameplayActor_DisableAbilityDeliveryInfo Parms{};

	Parms.BucketTag = std::move(BucketTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.EnableAbilityDeliveryInfo
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              BucketTag                                              (Parm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::EnableAbilityDeliveryInfo(const struct FGameplayTag& BucketTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "EnableAbilityDeliveryInfo");

	Params::BuildingGameplayActor_EnableAbilityDeliveryInfo Parms{};

	Parms.BucketTag = std::move(BucketTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.K2_AddGameplayCue
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayCueTag                                         (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&Context                                                (Parm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::K2_AddGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "K2_AddGameplayCue");

	Params::BuildingGameplayActor_K2_AddGameplayCue Parms{};

	Parms.GameplayCueTag = std::move(GameplayCueTag);
	Parms.Context = std::move(Context);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.K2_ExecuteGameplayCue
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayCueTag                                         (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayEffectContextHandle&Context                                                (Parm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::K2_ExecuteGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "K2_ExecuteGameplayCue");

	Params::BuildingGameplayActor_K2_ExecuteGameplayCue Parms{};

	Parms.GameplayCueTag = std::move(GameplayCueTag);
	Parms.Context = std::move(Context);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.K2_ExecuteGameplayCueWithParams
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayCueTag                                         (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    GameplayCueParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::K2_ExecuteGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "K2_ExecuteGameplayCueWithParams");

	Params::BuildingGameplayActor_K2_ExecuteGameplayCueWithParams Parms{};

	Parms.GameplayCueTag = std::move(GameplayCueTag);
	Parms.GameplayCueParameters = std::move(GameplayCueParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.K2_RemoveGameplayCue
// (Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayCueTag                                         (Parm, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::K2_RemoveGameplayCue(const struct FGameplayTag& GameplayCueTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "K2_RemoveGameplayCue");

	Params::BuildingGameplayActor_K2_RemoveGameplayCue Parms{};

	Parms.GameplayCueTag = std::move(GameplayCueTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.SetIgnoreInstigatorCollision
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldIgnore                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::SetIgnoreInstigatorCollision(bool bShouldIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "SetIgnoreInstigatorCollision");

	Params::BuildingGameplayActor_SetIgnoreInstigatorCollision Parms{};

	Parms.bShouldIgnore = bShouldIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.SetInitialVelocity
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InitialVelocity                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingGameplayActor::SetInitialVelocity(const struct FVector& InitialVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "SetInitialVelocity");

	Params::BuildingGameplayActor_SetInitialVelocity Parms{};

	Parms.InitialVelocity = std::move(InitialVelocity);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingGameplayActor.GetTargetingSourceTransform
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// EFortAbilityTargetingSource             Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform ABuildingGameplayActor::GetTargetingSourceTransform(EFortAbilityTargetingSource Source) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingGameplayActor", "GetTargetingSourceTransform");

	Params::BuildingGameplayActor_GetTargetingSourceTransform Parms{};

	Parms.Source = Source;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingCapturePointActor.OnCapturePointActiveStateChange
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bInActive                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::OnCapturePointActiveStateChange(bool bInActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnCapturePointActiveStateChange");

	Params::BuildingCapturePointActor_OnCapturePointActiveStateChange Parms{};

	Parms.bInActive = bInActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnCapturePointLockStateChange
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bInLocked                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::OnCapturePointLockStateChange(bool bInLocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnCapturePointLockStateChange");

	Params::BuildingCapturePointActor_OnCapturePointLockStateChange Parms{};

	Parms.bInLocked = bInLocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnCapturePointStateChange
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// ECaptureState                           InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::OnCapturePointStateChange(ECaptureState InState, EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnCapturePointStateChange");

	Params::BuildingCapturePointActor_OnCapturePointStateChange Parms{};

	Parms.InState = InState;
	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnEnterCapturePoint
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::OnEnterCapturePoint(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("BuildingCapturePointActor", "OnEnterCapturePoint");

	Params::BuildingCapturePointActor_OnEnterCapturePoint Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnLeaveCapturePoint
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::OnLeaveCapturePoint(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnLeaveCapturePoint");

	Params::BuildingCapturePointActor_OnLeaveCapturePoint Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnRep_bActivated
// (Final, Native, Protected)

void ABuildingCapturePointActor::OnRep_bActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnRep_bActivated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnRep_bLocked
// (Final, Native, Protected)

void ABuildingCapturePointActor::OnRep_bLocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnRep_bLocked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnRep_CaptureState
// (Final, Native, Protected)

void ABuildingCapturePointActor::OnRep_CaptureState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnRep_CaptureState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.OnRep_ReplicatedCapturePercentage
// (Final, Native, Protected)

void ABuildingCapturePointActor::OnRep_ReplicatedCapturePercentage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "OnRep_ReplicatedCapturePercentage");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.SetActivatedState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInActivated                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingCapturePointActor::SetActivatedState(bool bInActivated)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "SetActivatedState");

	Params::BuildingCapturePointActor_SetActivatedState Parms{};

	Parms.bInActivated = bInActivated;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingCapturePointActor.GetCaptureState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ECaptureState                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECaptureState ABuildingCapturePointActor::GetCaptureState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingCapturePointActor", "GetCaptureState");

	Params::BuildingCapturePointActor_GetCaptureState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingFlagSpawn.OnCarriedObjectAttachedEvent
// (Native, Event, Public, BlueprintEvent)

void ABuildingFlagSpawn::OnCarriedObjectAttachedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFlagSpawn", "OnCarriedObjectAttachedEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingFlagSpawn.OnCarriedObjectDetachedEvent
// (Native, Event, Public, BlueprintEvent)

void ABuildingFlagSpawn::OnCarriedObjectDetachedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFlagSpawn", "OnCarriedObjectDetachedEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingFlagSpawn.SpawnCarriedObject
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void ABuildingFlagSpawn::SpawnCarriedObject()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFlagSpawn", "SpawnCarriedObject");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingFlagSpawn.IsSpawnedObjectAwayFromBase
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingFlagSpawn::IsSpawnedObjectAwayFromBase() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFlagSpawn", "IsSpawnedObjectAwayFromBase");

	Params::BuildingFlagSpawn_IsSpawnedObjectAwayFromBase Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingItemCollectorActor.GetNumberOfTeamCaptures
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingItemCollectorActor::GetNumberOfTeamCaptures(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "GetNumberOfTeamCaptures");

	Params::BuildingItemCollectorActor_GetNumberOfTeamCaptures Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingItemCollectorActor.GetTeamDepositAmount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingItemCollectorActor::GetTeamDepositAmount(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "GetTeamDepositAmount");

	Params::BuildingItemCollectorActor_GetTeamDepositAmount Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingItemCollectorActor.GetTeamDepositGoal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingItemCollectorActor::GetTeamDepositGoal(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "GetTeamDepositGoal");

	Params::BuildingItemCollectorActor_GetTeamDepositGoal Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingItemCollectorActor.GetTeamReachedGoalCount
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingItemCollectorActor::GetTeamReachedGoalCount(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "GetTeamReachedGoalCount");

	Params::BuildingItemCollectorActor_GetTeamReachedGoalCount Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingItemCollectorActor.OnItemCollectorStateChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EFortItemCollectorState                 InItemCollectorState                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingItemCollectorActor::OnItemCollectorStateChanged(EFortItemCollectorState InItemCollectorState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnItemCollectorStateChanged");

	Params::BuildingItemCollectorActor_OnItemCollectorStateChanged Parms{};

	Parms.InItemCollectorState = InItemCollectorState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.OnRep_ControllingTeam
// (Final, Native, Protected)

void ABuildingItemCollectorActor::OnRep_ControllingTeam()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnRep_ControllingTeam");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.OnRep_ItemCollectorState
// (Final, Native, Protected)

void ABuildingItemCollectorActor::OnRep_ItemCollectorState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnRep_ItemCollectorState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.OnRep_TeamDepositAmounts
// (Final, Native, Protected)

void ABuildingItemCollectorActor::OnRep_TeamDepositAmounts()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnRep_TeamDepositAmounts");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.OnRep_TeamDepositGoals
// (Final, Native, Protected)

void ABuildingItemCollectorActor::OnRep_TeamDepositGoals()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnRep_TeamDepositGoals");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.OnTeamReachedDepositGoal
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EFortTeam                               InControllingTeam                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingItemCollectorActor::OnTeamReachedDepositGoal(EFortTeam InControllingTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "OnTeamReachedDepositGoal");

	Params::BuildingItemCollectorActor_OnTeamReachedDepositGoal Parms{};

	Parms.InControllingTeam = InControllingTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.SetItemCollectorState
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortItemCollectorState                 InItemCollectorState                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingItemCollectorActor::SetItemCollectorState(EFortItemCollectorState InItemCollectorState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "SetItemCollectorState");

	Params::BuildingItemCollectorActor_SetItemCollectorState Parms{};

	Parms.InItemCollectorState = InItemCollectorState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingItemCollectorActor.UpdateTeamDepositValues
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<int32>&                    DepositAmounts                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    DepositGoals                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void ABuildingItemCollectorActor::UpdateTeamDepositValues(const TArray<int32>& DepositAmounts, const TArray<int32>& DepositGoals)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingItemCollectorActor", "UpdateTeamDepositValues");

	Params::BuildingItemCollectorActor_UpdateTeamDepositValues Parms{};

	Parms.DepositAmounts = std::move(DepositAmounts);
	Parms.DepositGoals = std::move(DepositGoals);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.AddGoalsToWorldAssignment
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FFortAIGoalInfo>&   GoalInfos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::AddGoalsToWorldAssignment(class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const TArray<struct FFortAIGoalInfo>& GoalInfos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "AddGoalsToWorldAssignment");

	Params::FortAIGoalManager_AddGoalsToWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.GoalInfos = std::move(GoalInfos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.AddGoalToWorldAssignment
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FFortAIGoalInfo&           GoalInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::AddGoalToWorldAssignment(class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const struct FFortAIGoalInfo& GoalInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "AddGoalToWorldAssignment");

	Params::FortAIGoalManager_AddGoalToWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.GoalInfo = std::move(GoalInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.CreateWorldAssignment
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&WorldAssignmentIdentifier                              (Parm, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortAIGoalProvider>  GoalProvider                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortAIAssignmentIdentifier*     AssignmentIdentifier                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// EAssignmentCreationResult*              CreationResult                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIGoalManager::CreateWorldAssignment(class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& WorldAssignmentIdentifier, class UFortAIAssignmentSettings* AssignmentSettings, TSubclassOf<class UFortAIGoalProvider> GoalProvider, struct FFortAIAssignmentIdentifier* AssignmentIdentifier, EAssignmentCreationResult* CreationResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "CreateWorldAssignment");

	Params::FortAIGoalManager_CreateWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.WorldAssignmentIdentifier = std::move(WorldAssignmentIdentifier);
	Parms.AssignmentSettings = AssignmentSettings;
	Parms.GoalProvider = GoalProvider;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AssignmentIdentifier != nullptr)
		*AssignmentIdentifier = std::move(Parms.AssignmentIdentifier);

	if (CreationResult != nullptr)
		*CreationResult = Parms.CreationResult;
}


// Function FortniteGame.FortAIGoalManager.MakeGoalFromActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FFortAIGoalInfo*                 Goal                                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*&                    GoalActor                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bActorAlwaysPerceived                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bGoalActorAllowsUndermining                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIGoalManager::MakeGoalFromActor(struct FFortAIGoalInfo* Goal, const class UObject* WorldContextObject, const class AActor*& GoalActor, bool bActorAlwaysPerceived, bool bGoalActorAllowsUndermining)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "MakeGoalFromActor");

	Params::FortAIGoalManager_MakeGoalFromActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GoalActor = GoalActor;
	Parms.bActorAlwaysPerceived = bActorAlwaysPerceived;
	Parms.bGoalActorAllowsUndermining = bGoalActorAllowsUndermining;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Goal != nullptr)
		*Goal = std::move(Parms.Goal);
}


// Function FortniteGame.FortAIGoalManager.MakeGoalFromLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FFortAIGoalInfo*                 Goal                                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   GoalLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIGoalManager::MakeGoalFromLocation(struct FFortAIGoalInfo* Goal, const class UObject* WorldContextObject, const struct FVector& GoalLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "MakeGoalFromLocation");

	Params::FortAIGoalManager_MakeGoalFromLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GoalLocation = std::move(GoalLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Goal != nullptr)
		*Goal = std::move(Parms.Goal);
}


// Function FortniteGame.FortAIGoalManager.MakeGoalsFromActors
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortAIGoalInfo>*         Goals                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            GoalActors                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bActorsAlwaysPerceived                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bGoalActorsAllowUndermining                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIGoalManager::MakeGoalsFromActors(TArray<struct FFortAIGoalInfo>* Goals, const class UObject* WorldContextObject, const TArray<class AActor*>& GoalActors, bool bActorsAlwaysPerceived, bool bGoalActorsAllowUndermining)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "MakeGoalsFromActors");

	Params::FortAIGoalManager_MakeGoalsFromActors Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GoalActors = std::move(GoalActors);
	Parms.bActorsAlwaysPerceived = bActorsAlwaysPerceived;
	Parms.bGoalActorsAllowUndermining = bGoalActorsAllowUndermining;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Goals != nullptr)
		*Goals = std::move(Parms.Goals);
}


// Function FortniteGame.FortAIGoalManager.MakeGoalsFromLocations
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortAIGoalInfo>*         Goals                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           GoalLocations                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::MakeGoalsFromLocations(TArray<struct FFortAIGoalInfo>* Goals, const class UObject* WorldContextObject, const TArray<struct FVector>& GoalLocations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "MakeGoalsFromLocations");

	Params::FortAIGoalManager_MakeGoalsFromLocations Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GoalLocations = std::move(GoalLocations);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Goals != nullptr)
		*Goals = std::move(Parms.Goals);
}


// Function FortniteGame.FortAIGoalManager.MakeGoalsFromLocationsAndActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortAIGoalInfo>*         Goals                                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           GoalLocations                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class AActor*                     GoalActor                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIGoalManager::MakeGoalsFromLocationsAndActor(TArray<struct FFortAIGoalInfo>* Goals, const class UObject* WorldContextObject, const TArray<struct FVector>& GoalLocations, const class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "MakeGoalsFromLocationsAndActor");

	Params::FortAIGoalManager_MakeGoalsFromLocationsAndActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GoalLocations = std::move(GoalLocations);
	Parms.GoalActor = GoalActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Goals != nullptr)
		*Goals = std::move(Parms.Goals);
}


// Function FortniteGame.FortAIGoalManager.RemoveGoalFromWorldAssignment
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FFortAIGoalInfo&           GoalInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::RemoveGoalFromWorldAssignment(class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const struct FFortAIGoalInfo& GoalInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "RemoveGoalFromWorldAssignment");

	Params::FortAIGoalManager_RemoveGoalFromWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.GoalInfo = std::move(GoalInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.RemoveGoalsFromWorldAssignment
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FFortAIGoalInfo>&   GoalInfos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::RemoveGoalsFromWorldAssignment(class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const TArray<struct FFortAIGoalInfo>& GoalInfos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "RemoveGoalsFromWorldAssignment");

	Params::FortAIGoalManager_RemoveGoalsFromWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.GoalInfos = std::move(GoalInfos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.RemoveWorldAssignment
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)

void AFortAIGoalManager::RemoveWorldAssignment(const class UObject* WorldContextObject, const struct FFortAIAssignmentIdentifier& AssignmentIdentifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIGoalManager", "RemoveWorldAssignment");

	Params::FortAIGoalManager_RemoveWorldAssignment Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.AddGoal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           GoalActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        GoalSettings                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIGoalManager::AddGoal(class AActor* GoalActor, class UFortAIAssignmentSettings* GoalSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalManager", "AddGoal");

	Params::FortAIGoalManager_AddGoal Parms{};

	Parms.GoalActor = GoalActor;
	Parms.GoalSettings = GoalSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.AddGoalActorToAssignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIAssignment*                Assignment                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           GoalActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIGoalManager::AddGoalActorToAssignment(class UFortAIAssignment* Assignment, class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalManager", "AddGoalActorToAssignment");

	Params::FortAIGoalManager_AddGoalActorToAssignment Parms{};

	Parms.Assignment = Assignment;
	Parms.GoalActor = GoalActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIGoalManager.AddWorldAssignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           GoalActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignment*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIAssignment* AFortAIGoalManager::AddWorldAssignment(class UFortAIAssignmentSettings* AssignmentSettings, class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIGoalManager", "AddWorldAssignment");

	Params::FortAIGoalManager_AddWorldAssignment Parms{};

	Parms.AssignmentSettings = AssignmentSettings;
	Parms.GoalActor = GoalActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.SBAGrantedBuildingGameplayActor.GetOwnerStrategicBuildingActor
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AStrategicBuildingActor*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AStrategicBuildingActor* ASBAGrantedBuildingGameplayActor::GetOwnerStrategicBuildingActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SBAGrantedBuildingGameplayActor", "GetOwnerStrategicBuildingActor");

	Params::SBAGrantedBuildingGameplayActor_GetOwnerStrategicBuildingActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.ApplyProximityPulseEffects
// (Native, Protected)

void AStrategicBuildingActor::ApplyProximityPulseEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "ApplyProximityPulseEffects");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.AttemptIncrementLevelUnlockProgress
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InLevel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InProgressDelta                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AStrategicBuildingActor::AttemptIncrementLevelUnlockProgress(int32 InLevel, float InProgressDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "AttemptIncrementLevelUnlockProgress");

	Params::StrategicBuildingActor_AttemptIncrementLevelUnlockProgress Parms{};

	Parms.InLevel = InLevel;
	Parms.InProgressDelta = InProgressDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.GiveItemFromStrategicBuildingToPlayer
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UFortWorldItemDefinition*   ItemDefinition                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberToGive                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStrategicBuildingActor::GiveItemFromStrategicBuildingToPlayer(class AFortPlayerController* PlayerController, const class UFortWorldItemDefinition* ItemDefinition, int32 NumberToGive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GiveItemFromStrategicBuildingToPlayer");

	Params::StrategicBuildingActor_GiveItemFromStrategicBuildingToPlayer Parms{};

	Parms.PlayerController = PlayerController;
	Parms.ItemDefinition = ItemDefinition;
	Parms.NumberToGive = NumberToGive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnActiveStatusChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bNewActiveStatus                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AStrategicBuildingActor::OnActiveStatusChanged(bool bNewActiveStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnActiveStatusChanged");

	Params::StrategicBuildingActor_OnActiveStatusChanged Parms{};

	Parms.bNewActiveStatus = bNewActiveStatus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnConstructionEndedPlayEffects
// (BlueprintCosmetic, Native, Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   ConstructionLevel                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStrategicBuildingActor::OnConstructionEndedPlayEffects(int32 ConstructionLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnConstructionEndedPlayEffects");

	Params::StrategicBuildingActor_OnConstructionEndedPlayEffects Parms{};

	Parms.ConstructionLevel = ConstructionLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnConstructionStartedPlayEffects
// (BlueprintCosmetic, Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                                   ServerStartTime                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ServerEndTime                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CurrentServerTime                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ElapsedPct                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ConstructionLvl                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStrategicBuildingActor::OnConstructionStartedPlayEffects(float ServerStartTime, float ServerEndTime, float CurrentServerTime, float ElapsedPct, int32 ConstructionLvl)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnConstructionStartedPlayEffects");

	Params::StrategicBuildingActor_OnConstructionStartedPlayEffects Parms{};

	Parms.ServerStartTime = ServerStartTime;
	Parms.ServerEndTime = ServerEndTime;
	Parms.CurrentServerTime = CurrentServerTime;
	Parms.ElapsedPct = ElapsedPct;
	Parms.ConstructionLvl = ConstructionLvl;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnConstructionTickPlayEffects
// (BlueprintCosmetic, Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ElapsedPct                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ConstructionLvl                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AStrategicBuildingActor::OnConstructionTickPlayEffects(float DeltaTime, float ElapsedPct, int32 ConstructionLvl)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnConstructionTickPlayEffects");

	Params::StrategicBuildingActor_OnConstructionTickPlayEffects Parms{};

	Parms.DeltaTime = DeltaTime;
	Parms.ElapsedPct = ElapsedPct;
	Parms.ConstructionLvl = ConstructionLvl;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnRep_bIsActive
// (Native, Protected)

void AStrategicBuildingActor::OnRep_bIsActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnRep_bIsActive");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.OnRep_ConstructionProgress
// (Native, Protected)

void AStrategicBuildingActor::OnRep_ConstructionProgress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "OnRep_ConstructionProgress");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.ProcessDeferredTouchActors
// (Native, Protected)

void AStrategicBuildingActor::ProcessDeferredTouchActors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "ProcessDeferredTouchActors");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.SetupIndicators
// (Native, Protected)

void AStrategicBuildingActor::SetupIndicators()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "SetupIndicators");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.SetupVisibilityComponent
// (Native, Protected)

void AStrategicBuildingActor::SetupVisibilityComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "SetupVisibilityComponent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.StrategicBuildingActor.GetCurrentLevelUnlockProgress
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   InLevel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AStrategicBuildingActor::GetCurrentLevelUnlockProgress(int32 InLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GetCurrentLevelUnlockProgress");

	Params::StrategicBuildingActor_GetCurrentLevelUnlockProgress Parms{};

	Parms.InLevel = InLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.GetDeathEffectsLocation
// (Native, Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AStrategicBuildingActor::GetDeathEffectsLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GetDeathEffectsLocation");

	Params::StrategicBuildingActor_GetDeathEffectsLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.GetDeathEffectsRotation
// (Native, Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AStrategicBuildingActor::GetDeathEffectsRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GetDeathEffectsRotation");

	Params::StrategicBuildingActor_GetDeathEffectsRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.GetDeathEffectsScale
// (Native, Event, Protected, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AStrategicBuildingActor::GetDeathEffectsScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GetDeathEffectsScale");

	Params::StrategicBuildingActor_GetDeathEffectsScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.GetMaxLevelUnlockProgress
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   InLevel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AStrategicBuildingActor::GetMaxLevelUnlockProgress(int32 InLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "GetMaxLevelUnlockProgress");

	Params::StrategicBuildingActor_GetMaxLevelUnlockProgress Parms{};

	Parms.InLevel = InLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.StrategicBuildingActor.IsActive
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AStrategicBuildingActor::IsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("StrategicBuildingActor", "IsActive");

	Params::StrategicBuildingActor_IsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPBaseCornerstone.OnInvincibilityChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bIsInvincible                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPvPBaseCornerstone::OnInvincibilityChanged(bool bIsInvincible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPvPBaseCornerstone", "OnInvincibilityChanged");

	Params::FortPvPBaseCornerstone_OnInvincibilityChanged Parms{};

	Parms.bIsInvincible = bIsInvincible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPvPBaseCornerstone.OnRep_bInvincible
// (Final, Native, Protected)

void AFortPvPBaseCornerstone::OnRep_bInvincible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPvPBaseCornerstone", "OnRep_bInvincible");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPvPBaseCornerstone.SetInvincibility
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInInvincible                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPvPBaseCornerstone::SetInvincibility(bool bInInvincible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPvPBaseCornerstone", "SetInvincibility");

	Params::FortPvPBaseCornerstone_SetInvincibility Parms{};

	Parms.bInInvincible = bInInvincible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingRift.BroadcastRiftSpawningAI
// (Net, Native, Event, NetMulticast, Public)

void ABuildingRift::BroadcastRiftSpawningAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "BroadcastRiftSpawningAI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingRift.OnActivated
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingRift::OnActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingRift.OnDeactivated
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingRift::OnDeactivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnDeactivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingRift.OnPlaced
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingRift::OnPlaced()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnPlaced");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingRift.OnReceiveSpawnedAIPawn
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// class AFortAIPawn*                      SpawnedAI                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingRift::OnReceiveSpawnedAIPawn(class AFortAIPawn* SpawnedAI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnReceiveSpawnedAIPawn");

	Params::BuildingRift_OnReceiveSpawnedAIPawn Parms{};

	Parms.SpawnedAI = SpawnedAI;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingRift.OnRemoved
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingRift::OnRemoved()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnRemoved");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingRift.OnRep_RiftIsActive
// (Final, Native, Public)

void ABuildingRift::OnRep_RiftIsActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnRep_RiftIsActive");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingRift.OnRep_RiftIsVisible
// (Final, Native, Public)

void ABuildingRift::OnRep_RiftIsVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnRep_RiftIsVisible");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingRift.OnSpawnAI
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingRift::OnSpawnAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingRift", "OnSpawnAI");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCrackEffect.NetFadeOut
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AFortCrackEffect::NetFadeOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "NetFadeOut");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCrackEffect.NetOnHitCrack
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AFortCrackEffect::NetOnHitCrack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "NetOnHitCrack");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCrackEffect.OnBounceAnimationUpdate
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// const struct FFortBounceData&           BounceData                                             (Parm, NativeAccessSpecifierPublic)

void AFortCrackEffect::OnBounceAnimationUpdate(const struct FFortBounceData& BounceData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnBounceAnimationUpdate");

	Params::FortCrackEffect_OnBounceAnimationUpdate Parms{};

	Parms.BounceData = std::move(BounceData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortCrackEffect.OnFadeOut
// (Event, Public, BlueprintEvent)

void AFortCrackEffect::OnFadeOut()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnFadeOut");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCrackEffect.OnHitCrack
// (Event, Public, BlueprintEvent)

void AFortCrackEffect::OnHitCrack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnHitCrack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCrackEffect.OnRep_HitNormal
// (Native, Public)

void AFortCrackEffect::OnRep_HitNormal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnRep_HitNormal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCrackEffect.OnRep_PhysicalSurfaceType
// (Native, Public)

void AFortCrackEffect::OnRep_PhysicalSurfaceType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnRep_PhysicalSurfaceType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCrackEffect.OnStartDirectionEffect
// (Event, Public, BlueprintEvent)

void AFortCrackEffect::OnStartDirectionEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "OnStartDirectionEffect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCrackEffect.HasStartingPosition
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortCrackEffect::HasStartingPosition() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCrackEffect", "HasStartingPosition");

	Params::FortCrackEffect_HasStartingPosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterTargetInterface.GetObjectiveCompletionPercentage
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortAIEncounterTargetInterface::GetObjectiveCompletionPercentage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterTargetInterface", "GetObjectiveCompletionPercentage");

	Params::FortAIEncounterTargetInterface_GetObjectiveCompletionPercentage Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterTargetInterface.IsFloatingTarget
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortAIEncounterTargetInterface::IsFloatingTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterTargetInterface", "IsFloatingTarget");

	Params::FortAIEncounterTargetInterface_IsFloatingTarget Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAttachToActorInterface.GetActorAttachedTo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* IFortAttachToActorInterface::GetActorAttachedTo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAttachToActorInterface", "GetActorAttachedTo");

	Params::FortAttachToActorInterface_GetActorAttachedTo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingSMActor.AttachBuildingActorToMe
// (Native, Public, BlueprintCallable)
// Parameters:
// class ABuildingSMActor*                 ActorToAttach                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForceAttachment                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingSMActor::AttachBuildingActorToMe(class ABuildingSMActor* ActorToAttach, bool bForceAttachment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "AttachBuildingActorToMe");

	Params::BuildingSMActor_AttachBuildingActorToMe Parms{};

	Parms.ActorToAttach = ActorToAttach;
	Parms.bForceAttachment = bForceAttachment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.BlueprintAttemptBuildingUpgrade
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            PC                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   UpgradeLevelDelta                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::BlueprintAttemptBuildingUpgrade(class AFortPlayerController* PC, int32 UpgradeLevelDelta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "BlueprintAttemptBuildingUpgrade");

	Params::BuildingSMActor_BlueprintAttemptBuildingUpgrade Parms{};

	Parms.PC = PC;
	Parms.UpgradeLevelDelta = UpgradeLevelDelta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.BlueprintOnStructurallyUnstable
// (Native, Event, Protected, BlueprintEvent)

void ABuildingSMActor::BlueprintOnStructurallyUnstable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "BlueprintOnStructurallyUnstable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.DetachBuildingActorFromMe
// (Native, Public, BlueprintCallable)
// Parameters:
// class ABuildingSMActor*                 ActorToAttach                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBeingDestroyed                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingSMActor::DetachBuildingActorFromMe(class ABuildingSMActor* ActorToAttach, bool bBeingDestroyed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "DetachBuildingActorFromMe");

	Params::BuildingSMActor_DetachBuildingActorFromMe Parms{};

	Parms.ActorToAttach = ActorToAttach;
	Parms.bBeingDestroyed = bBeingDestroyed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.ForceIntoStructuralGridDuringRuntime
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void ABuildingSMActor::ForceIntoStructuralGridDuringRuntime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "ForceIntoStructuralGridDuringRuntime");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.GetAnimatingMID
// (Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ElementIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* ABuildingSMActor::GetAnimatingMID(int32 ElementIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "GetAnimatingMID");

	Params::BuildingSMActor_GetAnimatingMID Parms{};

	Parms.ElementIndex = ElementIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingSMActor.MulticastPlayFullHealthEffects
// (Net, Native, Event, NetMulticast, Protected, BlueprintCallable)

void ABuildingSMActor::MulticastPlayFullHealthEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "MulticastPlayFullHealthEffects");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnAttachToBuilding
// (Event, Public, BlueprintEvent)
// Parameters:
// class ABuildingSMActor*                 AttachedToBuilding                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::OnAttachToBuilding(class ABuildingSMActor* AttachedToBuilding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnAttachToBuilding");

	Params::BuildingSMActor_OnAttachToBuilding Parms{};

	Parms.AttachedToBuilding = AttachedToBuilding;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingSMActor.OnBounceAnimationUpdate
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// const struct FFortBounceData&           Data                                                   (Parm, NativeAccessSpecifierPublic)

void ABuildingSMActor::OnBounceAnimationUpdate(const struct FFortBounceData& Data)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnBounceAnimationUpdate");

	Params::BuildingSMActor_OnBounceAnimationUpdate Parms{};

	Parms.Data = std::move(Data);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingSMActor.OnDetachFromBuilding
// (Event, Public, BlueprintEvent)
// Parameters:
// class ABuildingSMActor*                 AttachedToBuilding                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bBeingDestroyed                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingSMActor::OnDetachFromBuilding(class ABuildingSMActor* AttachedToBuilding, bool bBeingDestroyed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnDetachFromBuilding");

	Params::BuildingSMActor_OnDetachFromBuilding Parms{};

	Parms.AttachedToBuilding = AttachedToBuilding;
	Parms.bBeingDestroyed = bBeingDestroyed;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingSMActor.OnDynamicShrinkAndDestroyEffectFinished
// (Native, Protected)

void ABuildingSMActor::OnDynamicShrinkAndDestroyEffectFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnDynamicShrinkAndDestroyEffectFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnLODOverrideEffectFinished
// (Native, Protected)

void ABuildingSMActor::OnLODOverrideEffectFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnLODOverrideEffectFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_bCollisionBlockedByPawns
// (Native, Protected)

void ABuildingSMActor::OnRep_bCollisionBlockedByPawns()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_bCollisionBlockedByPawns");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_bDoDynamicShrinkAndDestroyEffect
// (Native, Protected)

void ABuildingSMActor::OnRep_bDoDynamicShrinkAndDestroyEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_bDoDynamicShrinkAndDestroyEffect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_bRequiresDynamicLODEffect
// (Native, Protected)

void ABuildingSMActor::OnRep_bRequiresDynamicLODEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_bRequiresDynamicLODEffect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_BuildingReplacementType
// (Native, Protected)

void ABuildingSMActor::OnRep_BuildingReplacementType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_BuildingReplacementType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_bUnderConstruction
// (Native, Protected)

void ABuildingSMActor::OnRep_bUnderConstruction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_bUnderConstruction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_bUnderRepair
// (Native, Protected)

void ABuildingSMActor::OnRep_bUnderRepair()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_bUnderRepair");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_EditingPlayer
// (Native, Protected)

void ABuildingSMActor::OnRep_EditingPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_EditingPlayer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_MetaData
// (Native, Protected)

void ABuildingSMActor::OnRep_MetaData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_MetaData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_ReplicatedDrawScale3D
// (Native, Protected)

void ABuildingSMActor::OnRep_ReplicatedDrawScale3D()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_ReplicatedDrawScale3D");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_ReplicatedMIC
// (Native, Protected)

void ABuildingSMActor::OnRep_ReplicatedMIC()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_ReplicatedMIC");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_ResourceType
// (Native, Protected)
// Parameters:
// EFortResourceType                       OldType                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::OnRep_ResourceType(EFortResourceType OldType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_ResourceType");

	Params::BuildingSMActor_OnRep_ResourceType Parms{};

	Parms.OldType = OldType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRep_WeakSpotPositions
// (Native, Protected)

void ABuildingSMActor::OnRep_WeakSpotPositions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRep_WeakSpotPositions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.OnRepairStarted
// (Event, Public, BlueprintEvent)

void ABuildingSMActor::OnRepairStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "OnRepairStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingSMActor.RepairBuilding
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            RepairingController                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::RepairBuilding(class AFortPlayerController* RepairingController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "RepairBuilding");

	Params::BuildingSMActor_RepairBuilding Parms{};

	Parms.RepairingController = RepairingController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.UpdateDynamicShrinkAndDestroyEffectt
// (Native, Protected)
// Parameters:
// float                                   CurveValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::UpdateDynamicShrinkAndDestroyEffectt(float CurveValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "UpdateDynamicShrinkAndDestroyEffectt");

	Params::BuildingSMActor_UpdateDynamicShrinkAndDestroyEffectt Parms{};

	Parms.CurveValue = CurveValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.UpdateLODOverrideEffect
// (Native, Protected)
// Parameters:
// float                                   CurveValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::UpdateLODOverrideEffect(float CurveValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "UpdateLODOverrideEffect");

	Params::BuildingSMActor_UpdateLODOverrideEffect Parms{};

	Parms.CurveValue = CurveValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.UpdateRepairMaterialAnim
// (Native, Protected)
// Parameters:
// float                                   CurveValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingSMActor::UpdateRepairMaterialAnim(float CurveValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "UpdateRepairMaterialAnim");

	Params::BuildingSMActor_UpdateRepairMaterialAnim Parms{};

	Parms.CurveValue = CurveValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingSMActor.GetBuildingMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UStaticMeshComponent*             ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UStaticMeshComponent* ABuildingSMActor::GetBuildingMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "GetBuildingMeshComponent");

	Params::BuildingSMActor_GetBuildingMeshComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingSMActor.GetLogicalBuildingIndex
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingSMActor::GetLogicalBuildingIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "GetLogicalBuildingIndex");

	Params::BuildingSMActor_GetLogicalBuildingIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingSMActor.HasDestructionLoot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingSMActor::HasDestructionLoot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "HasDestructionLoot");

	Params::BuildingSMActor_HasDestructionLoot Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingSMActor.IsStructurallySupported
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingSMActor::IsStructurallySupported() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingSMActor", "IsStructurallySupported");

	Params::BuildingSMActor_IsStructurallySupported Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingContainer.BounceContainer
// (Native, Public)

void ABuildingContainer::BounceContainer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "BounceContainer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingContainer.GetLootTier
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingContainer::GetLootTier()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "GetLootTier");

	Params::BuildingContainer_GetLootTier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingContainer.OnBeginSearch
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnBeginSearch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnBeginSearch");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnLoot
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnLoot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnLoot");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnLootRepeat
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnLootRepeat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnLootRepeat");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnLootReset
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnLootReset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnLootReset");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnRaiseTreasure
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnRaiseTreasure()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnRaiseTreasure");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnRep_bAlreadySearched
// (Native, Public)

void ABuildingContainer::OnRep_bAlreadySearched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnRep_bAlreadySearched");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingContainer.OnSearchInterrupted
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnSearchInterrupted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnSearchInterrupted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.OnSetSearched
// (Event, Public, BlueprintEvent)

void ABuildingContainer::OnSetSearched()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "OnSetSearched");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingContainer.RaiseTreasure
// (Final, Native, Public, BlueprintCallable)

void ABuildingContainer::RaiseTreasure()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingContainer", "RaiseTreasure");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.GetContainerNameAndLevelKey
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName AKeepItemContainer::GetContainerNameAndLevelKey()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "GetContainerNameAndLevelKey");

	Params::KeepItemContainer_GetContainerNameAndLevelKey Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepItemContainer.InitializeContainer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InitUpgradeLevel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepItemContainer::InitializeContainer(int32 InitUpgradeLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "InitializeContainer");

	Params::KeepItemContainer_InitializeContainer Parms{};

	Parms.InitUpgradeLevel = InitUpgradeLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.OnRep_HostUpgradeLevel
// (Final, Native, Public)

void AKeepItemContainer::OnRep_HostUpgradeLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "OnRep_HostUpgradeLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.OnRep_SearchedBy
// (Final, Native, Protected)

void AKeepItemContainer::OnRep_SearchedBy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "OnRep_SearchedBy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.ResetContainer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepItemContainer::ResetContainer(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "ResetContainer");

	Params::KeepItemContainer_ResetContainer Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.RestoreLoot
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepItemContainer::RestoreLoot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "RestoreLoot");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepItemContainer.GetLootTierOverride
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeepItemContainer::GetLootTierOverride() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepItemContainer", "GetLootTierOverride");

	Params::KeepItemContainer_GetLootTierOverride Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingFloor.IsBalcony
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingFloor::IsBalcony() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFloor", "IsBalcony");

	Params::BuildingFloor_IsBalcony Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingFoundation.OnRep_LevelToStream
// (Native, Protected)

void ABuildingFoundation::OnRep_LevelToStream()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingFoundation", "OnRep_LevelToStream");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.GetBuildingActorsInBase
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// TArray<class ABuildingSMActor*>         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ABuildingSMActor*> AFortConstructorBASE::GetBuildingActorsInBase()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "GetBuildingActorsInBase");

	Params::FortConstructorBASE_GetBuildingActorsInBase Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortConstructorBASE.OnBaseCollisionTouched
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnBaseCollisionTouched(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("FortConstructorBASE", "OnBaseCollisionTouched");

	Params::FortConstructorBASE_OnBaseCollisionTouched Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.OnBaseCollisionUnTouched
// (Final, Native, Private)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnBaseCollisionUnTouched(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnBaseCollisionUnTouched");

	Params::FortConstructorBASE_OnBaseCollisionUnTouched Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.OnBasePawnDestroyed
// (Final, Native, Private)
// Parameters:
// class AFortPawn*                        Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnBasePawnDestroyed(class AFortPawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnBasePawnDestroyed");

	Params::FortConstructorBASE_OnBasePawnDestroyed Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.OnBasePawnDied
// (Final, Native, Private, HasDefaults)
// Parameters:
// float                                   Damage                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AController*                      InstigatedBy                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPawn*                        Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnBasePawnDied(float Damage, class AController* InstigatedBy, class AActor* DamageCauser, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& Momentum, class AFortPawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnBasePawnDied");

	Params::FortConstructorBASE_OnBasePawnDied Parms{};

	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.Momentum = std::move(Momentum);
	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.OnPawnAddedToBase
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPawn*                        Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnPawnAddedToBase(class AFortPawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnPawnAddedToBase");

	Params::FortConstructorBASE_OnPawnAddedToBase Parms{};

	Parms.Pawn = Pawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortConstructorBASE.OnPawnRemovedFromBase
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPawn*                        Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnPawnRemovedFromBase(class AFortPawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnPawnRemovedFromBase");

	Params::FortConstructorBASE_OnPawnRemovedFromBase Parms{};

	Parms.Pawn = Pawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortConstructorBASE.OnPlaced
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class UAbilitySystemComponent*          InstigatorAbilitySystemComponent                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::OnPlaced(class UAbilitySystemComponent* InstigatorAbilitySystemComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnPlaced");

	Params::FortConstructorBASE_OnPlaced Parms{};

	Parms.InstigatorAbilitySystemComponent = InstigatorAbilitySystemComponent;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortConstructorBASE.OnRep_ReplicatedAffectedNeighbors
// (Final, Native, Private)

void AFortConstructorBASE::OnRep_ReplicatedAffectedNeighbors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "OnRep_ReplicatedAffectedNeighbors");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConstructorBASE.StartBuildingActorVisuals
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// class ABuildingSMActor*                 BuildingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             EffectMeshComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::StartBuildingActorVisuals(class ABuildingSMActor* BuildingActor, class UStaticMeshComponent* EffectMeshComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "StartBuildingActorVisuals");

	Params::FortConstructorBASE_StartBuildingActorVisuals Parms{};

	Parms.BuildingActor = BuildingActor;
	Parms.EffectMeshComp = EffectMeshComp;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortConstructorBASE.StopBuildingActorVisuals
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// class ABuildingSMActor*                 BuildingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             EffectMeshComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::StopBuildingActorVisuals(class ABuildingSMActor* BuildingActor, class UStaticMeshComponent* EffectMeshComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "StopBuildingActorVisuals");

	Params::FortConstructorBASE_StopBuildingActorVisuals Parms{};

	Parms.BuildingActor = BuildingActor;
	Parms.EffectMeshComp = EffectMeshComp;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortConstructorBASE.AddToEffectList
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FBASEGameplayEffect>*     EffectList                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayEffect>      Effect                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::AddToEffectList(TArray<struct FBASEGameplayEffect>* EffectList, TSubclassOf<class UGameplayEffect> Effect) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "AddToEffectList");

	Params::FortConstructorBASE_AddToEffectList Parms{};

	Parms.Effect = Effect;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (EffectList != nullptr)
		*EffectList = std::move(Parms.EffectList);
}


// Function FortniteGame.FortConstructorBASE.AddToEffectListWithLevelOverride
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FBASEGameplayEffect>*     EffectList                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayEffect>      Effect                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortConstructorBASE::AddToEffectListWithLevelOverride(TArray<struct FBASEGameplayEffect>* EffectList, TSubclassOf<class UGameplayEffect> Effect, int32 Level) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConstructorBASE", "AddToEffectListWithLevelOverride");

	Params::FortConstructorBASE_AddToEffectListWithLevelOverride Parms{};

	Parms.Effect = Effect;
	Parms.Level = Level;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (EffectList != nullptr)
		*EffectList = std::move(Parms.EffectList);
}


// Function FortniteGame.FortTrack.GetOutgoingNeighborFromSpline
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class USplineComponent*                 InSpline                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InReverseDirection                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortTrack**                      OutNeighbor                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTrack::GetOutgoingNeighborFromSpline(class USplineComponent* InSpline, bool InReverseDirection, class AFortTrack** OutNeighbor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "GetOutgoingNeighborFromSpline");

	Params::FortTrack_GetOutgoingNeighborFromSpline Parms{};

	Parms.InSpline = InSpline;
	Parms.InReverseDirection = InReverseDirection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutNeighbor != nullptr)
		*OutNeighbor = Parms.OutNeighbor;
}


// Function FortniteGame.FortTrack.GetPathDistanceToTrack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortTrack*                       TargetTrack                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USplineComponent*                 InCurrentSpline                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CurrentDistanceAlongSpline                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InReverseDirection                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortTrack::GetPathDistanceToTrack(class AFortTrack* TargetTrack, class USplineComponent* InCurrentSpline, float CurrentDistanceAlongSpline, bool InReverseDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "GetPathDistanceToTrack");

	Params::FortTrack_GetPathDistanceToTrack Parms{};

	Parms.TargetTrack = TargetTrack;
	Parms.InCurrentSpline = InCurrentSpline;
	Parms.CurrentDistanceAlongSpline = CurrentDistanceAlongSpline;
	Parms.InReverseDirection = InReverseDirection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrack.GetSplineFromIncomingNeighbor
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortTrack*                       InNeighbor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USplineComponent**                OutSpline                                              (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutReverseDirection                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTrack::GetSplineFromIncomingNeighbor(class AFortTrack* InNeighbor, class USplineComponent** OutSpline, bool* OutReverseDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "GetSplineFromIncomingNeighbor");

	Params::FortTrack_GetSplineFromIncomingNeighbor Parms{};

	Parms.InNeighbor = InNeighbor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSpline != nullptr)
		*OutSpline = Parms.OutSpline;

	if (OutReverseDirection != nullptr)
		*OutReverseDirection = Parms.OutReverseDirection;
}


// Function FortniteGame.FortTrack.GetSplineFromPositionAndOrientation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InLocation                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  InRotation                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class USplineComponent**                OutSpline                                              (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutDistanceAlongSpline                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   OutReverseDirection                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTrack::GetSplineFromPositionAndOrientation(const struct FVector& InLocation, const struct FRotator& InRotation, class USplineComponent** OutSpline, float* OutDistanceAlongSpline, bool* OutReverseDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "GetSplineFromPositionAndOrientation");

	Params::FortTrack_GetSplineFromPositionAndOrientation Parms{};

	Parms.InLocation = std::move(InLocation);
	Parms.InRotation = std::move(InRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSpline != nullptr)
		*OutSpline = Parms.OutSpline;

	if (OutDistanceAlongSpline != nullptr)
		*OutDistanceAlongSpline = Parms.OutDistanceAlongSpline;

	if (OutReverseDirection != nullptr)
		*OutReverseDirection = Parms.OutReverseDirection;
}


// Function FortniteGame.FortTrack.InitializeTrack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             InTrackMeshComp1                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             InTrackMeshComp2                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USplineComponent*                 InSplineComp1                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USplineComponent*                 InSplineComp2                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  InSwitchCompBase                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              InSwitchComp                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTrack::InitializeTrack(class UStaticMeshComponent* InTrackMeshComp1, class UStaticMeshComponent* InTrackMeshComp2, class USplineComponent* InSplineComp1, class USplineComponent* InSplineComp2, class USceneComponent* InSwitchCompBase, class UPrimitiveComponent* InSwitchComp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "InitializeTrack");

	Params::FortTrack_InitializeTrack Parms{};

	Parms.InTrackMeshComp1 = InTrackMeshComp1;
	Parms.InTrackMeshComp2 = InTrackMeshComp2;
	Parms.InSplineComp1 = InSplineComp1;
	Parms.InSplineComp2 = InSplineComp2;
	Parms.InSwitchCompBase = InSwitchCompBase;
	Parms.InSwitchComp = InSwitchComp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrack.IsConnectedToTrack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortTrack*                       TargetTrack                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTrack::IsConnectedToTrack(class AFortTrack* TargetTrack)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "IsConnectedToTrack");

	Params::FortTrack_IsConnectedToTrack Parms{};

	Parms.TargetTrack = TargetTrack;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrack.IsConnectedToTrackList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class AFortTrack*>&        TargetTracks                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTrack::IsConnectedToTrackList(const TArray<class AFortTrack*>& TargetTracks)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "IsConnectedToTrackList");

	Params::FortTrack_IsConnectedToTrackList Parms{};

	Parms.TargetTracks = std::move(TargetTracks);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrack.OnConfigurationChanged
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   NewConfigurationIdx                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OldConfigurationIdx                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTrack::OnConfigurationChanged(int32 NewConfigurationIdx, int32 OldConfigurationIdx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "OnConfigurationChanged");

	Params::FortTrack_OnConfigurationChanged Parms{};

	Parms.NewConfigurationIdx = NewConfigurationIdx;
	Parms.OldConfigurationIdx = OldConfigurationIdx;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortTrack.OnRep_ConfigurationIdx
// (Native, Protected)

void AFortTrack::OnRep_ConfigurationIdx()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "OnRep_ConfigurationIdx");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrack.OnRep_SwitchState
// (Native, Protected)

void AFortTrack::OnRep_SwitchState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "OnRep_SwitchState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrack.OnSwitchStateChanged
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   NewSwitchState                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OldSwitchState                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumSwitchStates                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTrack::OnSwitchStateChanged(int32 NewSwitchState, int32 OldSwitchState, int32 NumSwitchStates)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrack", "OnSwitchStateChanged");

	Params::FortTrack_OnSwitchStateChanged Parms{};

	Parms.NewSwitchState = NewSwitchState;
	Parms.OldSwitchState = OldSwitchState;
	Parms.NumSwitchStates = NumSwitchStates;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.OutpostStructureBase.OnOutpostOwnerStructureLevelChanged
// (Event, Public, BlueprintEvent)

void AOutpostStructureBase::OnOutpostOwnerStructureLevelChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OutpostStructureBase", "OnOutpostOwnerStructureLevelChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.OutpostStructureBase.OnRep_OutpostOwnerStructureLevel
// (Final, Native, Public)

void AOutpostStructureBase::OnRep_OutpostOwnerStructureLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OutpostStructureBase", "OnRep_OutpostOwnerStructureLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.OutpostStructureBase.GetOutpostOwnerStructureLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AOutpostStructureBase::GetOutpostOwnerStructureLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("OutpostStructureBase", "GetOutpostOwnerStructureLevel");

	Params::OutpostStructureBase_GetOutpostOwnerStructureLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostCraftingTable.Activate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostCraftingTable::Activate(class AFortPlayerControllerOutpost* InPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "Activate");

	Params::BuildingOutpostCraftingTable_Activate Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostCraftingTable.Deactivate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostCraftingTable::Deactivate(class AFortPlayerControllerOutpost* InPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "Deactivate");

	Params::BuildingOutpostCraftingTable_Deactivate Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostCraftingTable.CanActivate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingOutpostCraftingTable::CanActivate(class AFortPlayerControllerOutpost* InPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "CanActivate");

	Params::BuildingOutpostCraftingTable_CanActivate Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostCraftingTable.GetActivationCost
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutWorldItems                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void ABuildingOutpostCraftingTable::GetActivationCost(class AFortPlayerControllerOutpost* InPC, TArray<struct FFortItemQuantityPair>* OutWorldItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "GetActivationCost");

	Params::BuildingOutpostCraftingTable_GetActivationCost Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldItems != nullptr)
		*OutWorldItems = std::move(Parms.OutWorldItems);
}


// Function FortniteGame.BuildingOutpostCraftingTable.GetNumberOfItemsPerActivation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostCraftingTable::GetNumberOfItemsPerActivation(class AFortPlayerControllerOutpost* InPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "GetNumberOfItemsPerActivation");

	Params::BuildingOutpostCraftingTable_GetNumberOfItemsPerActivation Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostCraftingTable.GetNumberOfItemsRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostCraftingTable::GetNumberOfItemsRemaining(class AFortPlayerControllerOutpost* InPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "GetNumberOfItemsRemaining");

	Params::BuildingOutpostCraftingTable_GetNumberOfItemsRemaining Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostCraftingTable.IsActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InPC                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingOutpostCraftingTable::IsActive(class AFortPlayerControllerOutpost* InPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostCraftingTable", "IsActive");

	Params::BuildingOutpostCraftingTable_IsActive Parms{};

	Parms.InPC = InPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.AbortDisintegration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostFabricator::AbortDisintegration(class AFortPlayerControllerOutpost* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "AbortDisintegration");

	Params::BuildingOutpostFabricator_AbortDisintegration Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostFabricator.CanDisintegrateItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::CanDisintegrateItem(class AFortPlayerControllerOutpost* FortPC, class UFortWorldItem* Item, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "CanDisintegrateItem");

	Params::BuildingOutpostFabricator_CanDisintegrateItem Parms{};

	Parms.FortPC = FortPC;
	Parms.Item = Item;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.DisintegrateItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostFabricator::DisintegrateItem(class AFortPlayerControllerOutpost* FortPC, class UFortWorldItem* Item, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "DisintegrateItem");

	Params::BuildingOutpostFabricator_DisintegrateItem Parms{};

	Parms.FortPC = FortPC;
	Parms.Item = Item;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostFabricator.FabricateItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDef                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostFabricator::FabricateItem(class AFortPlayerControllerOutpost* FortPC, class UFortWorldItemDefinition* ItemDef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "FabricateItem");

	Params::BuildingOutpostFabricator_FabricateItem Parms{};

	Parms.FortPC = FortPC;
	Parms.ItemDef = ItemDef;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostFabricator.GetAvailableRecipes
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortInventoryFilter                    InventoryFilter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SearchFilter                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UFortItem*>                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortItem*> ABuildingOutpostFabricator::GetAvailableRecipes(class AFortPlayerControllerOutpost* FortPC, EFortInventoryFilter InventoryFilter, const class FString& SearchFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetAvailableRecipes");

	Params::BuildingOutpostFabricator_GetAvailableRecipes Parms{};

	Parms.FortPC = FortPC;
	Parms.InventoryFilter = InventoryFilter;
	Parms.SearchFilter = std::move(SearchFilter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetDisintegrationDurationInSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetDisintegrationDurationInSeconds(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetDisintegrationDurationInSeconds");

	Params::BuildingOutpostFabricator_GetDisintegrationDurationInSeconds Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetDisintegrationDurationInSecondsForItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetDisintegrationDurationInSecondsForItem(class UFortWorldItem* Item, int32 Count) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetDisintegrationDurationInSecondsForItem");

	Params::BuildingOutpostFabricator_GetDisintegrationDurationInSecondsForItem Parms{};

	Parms.Item = Item;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetDisintegrationMinutesRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetDisintegrationMinutesRemaining(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetDisintegrationMinutesRemaining");

	Params::BuildingOutpostFabricator_GetDisintegrationMinutesRemaining Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetDisintegrationSecondsRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetDisintegrationSecondsRemaining(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetDisintegrationSecondsRemaining");

	Params::BuildingOutpostFabricator_GetDisintegrationSecondsRemaining Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetDisintegrationStartTime
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDateTime                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

struct FDateTime ABuildingOutpostFabricator::GetDisintegrationStartTime(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetDisintegrationStartTime");

	Params::BuildingOutpostFabricator_GetDisintegrationStartTime Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetGooFromDisintegrationAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortWorldItem*             Item                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetGooFromDisintegrationAmount(const class UFortWorldItem* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetGooFromDisintegrationAmount");

	Params::BuildingOutpostFabricator_GetGooFromDisintegrationAmount Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetGooToFabricateAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortWorldItem*             Item                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetGooToFabricateAmount(const class UFortWorldItem* Item) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetGooToFabricateAmount");

	Params::BuildingOutpostFabricator_GetGooToFabricateAmount Parms{};

	Parms.Item = Item;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetIncomingGooAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetIncomingGooAmount(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetIncomingGooAmount");

	Params::BuildingOutpostFabricator_GetIncomingGooAmount Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetIncomingGooAmountProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetIncomingGooAmountProgress(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetIncomingGooAmountProgress");

	Params::BuildingOutpostFabricator_GetIncomingGooAmountProgress Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetMaxGooCapacity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetMaxGooCapacity(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetMaxGooCapacity");

	Params::BuildingOutpostFabricator_GetMaxGooCapacity Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetPlayerItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortInventoryFilter                    InventoryFilter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SearchFilter                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UFortItem*>                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortItem*> ABuildingOutpostFabricator::GetPlayerItems(class AFortPlayerControllerOutpost* FortPC, EFortInventoryFilter InventoryFilter, const class FString& SearchFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetPlayerItems");

	Params::BuildingOutpostFabricator_GetPlayerItems Parms{};

	Parms.FortPC = FortPC;
	Parms.InventoryFilter = InventoryFilter;
	Parms.SearchFilter = std::move(SearchFilter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.GetStoredGooAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostFabricator::GetStoredGooAmount(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "GetStoredGooAmount");

	Params::BuildingOutpostFabricator_GetStoredGooAmount Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostFabricator.IsDisintegrating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingOutpostFabricator::IsDisintegrating(class AFortPlayerControllerOutpost* FortPC) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostFabricator", "IsDisintegrating");

	Params::BuildingOutpostFabricator_IsDisintegrating Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.ApplyTempWeaponMaterialOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInterface*               MaterialOverride                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::ApplyTempWeaponMaterialOverride(class UMaterialInterface* MaterialOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ApplyTempWeaponMaterialOverride");

	Params::FortWeapon_ApplyTempWeaponMaterialOverride Parms{};

	Parms.MaterialOverride = MaterialOverride;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.ClientGivenTo
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// class APawn*                            P                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::ClientGivenTo(class APawn* P)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ClientGivenTo");

	Params::FortWeapon_ClientGivenTo Parms{};

	Parms.P = P;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.ClientReportShotFlags
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// uint32                                  ShotFlags                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ShotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::ClientReportShotFlags(uint32 ShotFlags, int32 ShotIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ClientReportShotFlags");

	Params::FortWeapon_ClientReportShotFlags Parms{};

	Parms.ShotFlags = ShotFlags;
	Parms.ShotIndex = ShotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.DetermineReticleColor
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FColor                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FColor AFortWeapon::DetermineReticleColor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "DetermineReticleColor");

	Params::FortWeapon_DetermineReticleColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GameplayCue_Impact
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortWeapon::GameplayCue_Impact(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GameplayCue_Impact");

	Params::FortWeapon_GameplayCue_Impact Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.GameplayCue_Weapons_Activation
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortWeapon::GameplayCue_Weapons_Activation(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GameplayCue_Weapons_Activation");

	Params::FortWeapon_GameplayCue_Weapons_Activation Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.GameplayCue_Weapons_ChargeUp
// (Native, Protected)
// Parameters:
// EGameplayCueEvent                       EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    Parameters                                             (Parm, NativeAccessSpecifierPublic)

void AFortWeapon::GameplayCue_Weapons_ChargeUp(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GameplayCue_Weapons_ChargeUp");

	Params::FortWeapon_GameplayCue_Weapons_ChargeUp Parms{};

	Parms.EventType = EventType;
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.GetActiveAlterations
// (Final, Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<class UFortAlterationItemDefinition*>*outActiveAlterations                                   (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AFortWeapon::GetActiveAlterations(TArray<class UFortAlterationItemDefinition*>* outActiveAlterations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetActiveAlterations");

	Params::FortWeapon_GetActiveAlterations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outActiveAlterations != nullptr)
		*outActiveAlterations = std::move(Parms.outActiveAlterations);
}


// Function FortniteGame.FortWeapon.K2_OnUnEquip
// (Event, Public, BlueprintEvent)

void AFortWeapon::K2_OnUnEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "K2_OnUnEquip");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnAmmoCountChanged
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)

void AFortWeapon::OnAmmoCountChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnAmmoCountChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnEndCharge
// (Event, Protected, BlueprintEvent)

void AFortWeapon::OnEndCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnEndCharge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnEquippedWeaponDestory
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)

void AFortWeapon::OnEquippedWeaponDestory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnEquippedWeaponDestory");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnEquippedWeaponDestroyWrapper
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AFortWeapon::OnEquippedWeaponDestroyWrapper()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnEquippedWeaponDestroyWrapper");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.OnInitAlteration
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UFortAlterationItemDefinition*    NewAlteration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::OnInitAlteration(class UFortAlterationItemDefinition* NewAlteration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnInitAlteration");

	Params::FortWeapon_OnInitAlteration Parms{};

	Parms.NewAlteration = NewAlteration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnInitCosmeticAlterations
// (Event, Protected, BlueprintEvent)
// Parameters:
// const struct FFortCosmeticModification& CosmeticMod                                            (Parm, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         DynamicMaterialInstance                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::OnInitCosmeticAlterations(const struct FFortCosmeticModification& CosmeticMod, class UMaterialInstanceDynamic* DynamicMaterialInstance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnInitCosmeticAlterations");

	Params::FortWeapon_OnInitCosmeticAlterations Parms{};

	Parms.CosmeticMod = std::move(CosmeticMod);
	Parms.DynamicMaterialInstance = DynamicMaterialInstance;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnOutOfAmmoFire
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)

void AFortWeapon::OnOutOfAmmoFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnOutOfAmmoFire");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnPawnMontageStarted
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     PawnMontage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::OnPawnMontageStarted(class UAnimMontage* PawnMontage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnPawnMontageStarted");

	Params::FortWeapon_OnPawnMontageStarted Parms{};

	Parms.PawnMontage = PawnMontage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.OnPlayImpactFX
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// EPhysicalSurface                        ImpactPhysicalSurface                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UParticleSystemComponent*         SpawnedPSC                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::OnPlayImpactFX(const struct FHitResult& HitResult, EPhysicalSurface ImpactPhysicalSurface, class UParticleSystemComponent* SpawnedPSC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnPlayImpactFX");

	Params::FortWeapon_OnPlayImpactFX Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.ImpactPhysicalSurface = ImpactPhysicalSurface;
	Parms.SpawnedPSC = SpawnedPSC;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnPlayReloadFX
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)
// Parameters:
// EFortReloadFXState                      ReloadStage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::OnPlayReloadFX(EFortReloadFXState ReloadStage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnPlayReloadFX");

	Params::FortWeapon_OnPlayReloadFX Parms{};

	Parms.ReloadStage = ReloadStage;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnPlayWeaponFireFX
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bPersistentFire                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::OnPlayWeaponFireFX(bool bPersistentFire)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnPlayWeaponFireFX");

	Params::FortWeapon_OnPlayWeaponFireFX Parms{};

	Parms.bPersistentFire = bPersistentFire;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnReachedMaxCharge
// (Event, Protected, BlueprintEvent)

void AFortWeapon::OnReachedMaxCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnReachedMaxCharge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnReachedMinCharge
// (Event, Protected, BlueprintEvent)

void AFortWeapon::OnReachedMinCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnReachedMinCharge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnRep_AmmoCount
// (Native, Protected)

void AFortWeapon::OnRep_AmmoCount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnRep_AmmoCount");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.OnRep_ReplicatedAppliedAlterations
// (Native, Protected)

void AFortWeapon::OnRep_ReplicatedAppliedAlterations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnRep_ReplicatedAppliedAlterations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.OnRep_ReplicatedWeaponData
// (Native, Protected)

void AFortWeapon::OnRep_ReplicatedWeaponData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnRep_ReplicatedWeaponData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.OnSetTargeting
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bNewIsTargeting                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::OnSetTargeting(bool bNewIsTargeting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnSetTargeting");

	Params::FortWeapon_OnSetTargeting Parms{};

	Parms.bNewIsTargeting = bNewIsTargeting;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.OnStartCharge
// (Event, Protected, BlueprintEvent)

void AFortWeapon::OnStartCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnStartCharge");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnStopWeaponFireFX
// (BlueprintCosmetic, Event, Protected, BlueprintEvent)

void AFortWeapon::OnStopWeaponFireFX()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnStopWeaponFireFX");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnWeaponAttached
// (Event, Public, BlueprintEvent)

void AFortWeapon::OnWeaponAttached()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnWeaponAttached");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortWeapon.OnWeaponVisibilityChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::OnWeaponVisibilityChanged(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "OnWeaponVisibilityChanged");

	Params::FortWeapon_OnWeaponVisibilityChanged Parms{};

	Parms.bVisible = bVisible;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortWeapon.PlayNativeImpactFX
// (Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FGameplayCueParameters&    GameplayCueParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortWeapon::PlayNativeImpactFX(const struct FHitResult& HitResult, const struct FGameplayCueParameters& GameplayCueParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "PlayNativeImpactFX");

	Params::FortWeapon_PlayNativeImpactFX Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.GameplayCueParameters = std::move(GameplayCueParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.PlayReloadFX
// (BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// EFortReloadFXState                      ReloadStage                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::PlayReloadFX(EFortReloadFXState ReloadStage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "PlayReloadFX");

	Params::FortWeapon_PlayReloadFX Parms{};

	Parms.ReloadStage = ReloadStage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.PlayWeaponFireFX
// (BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bSecondaryFire                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::PlayWeaponFireFX(bool bSecondaryFire)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "PlayWeaponFireFX");

	Params::FortWeapon_PlayWeaponFireFX Parms{};

	Parms.bSecondaryFire = bSecondaryFire;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.ResetTempWeaponMaterialOverride
// (Final, Native, Public, BlueprintCallable)

void AFortWeapon::ResetTempWeaponMaterialOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ResetTempWeaponMaterialOverride");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.ServerResetShotReport
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortWeapon::ServerResetShotReport()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ServerResetShotReport");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.ServerStartCharge
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortWeapon::ServerStartCharge()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "ServerStartCharge");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.SetShouldDrawNativeReticle
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bInShouldDrawReticle                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::SetShouldDrawNativeReticle(bool bInShouldDrawReticle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "SetShouldDrawNativeReticle");

	Params::FortWeapon_SetShouldDrawNativeReticle Parms{};

	Parms.bInShouldDrawReticle = bInShouldDrawReticle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.SetWeaponVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bDesiredVisibility                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bForceUpdate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortWeapon::SetWeaponVisibility(bool bDesiredVisibility, bool bForceUpdate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "SetWeaponVisibility");

	Params::FortWeapon_SetWeaponVisibility Parms{};

	Parms.bDesiredVisibility = bDesiredVisibility;
	Parms.bForceUpdate = bForceUpdate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.StopWeaponFireFX
// (BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortWeapon::StopWeaponFireFX()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "StopWeaponFireFX");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.UseWeaponDurability
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DurabilityScale                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeapon::UseWeaponDurability(float DurabilityScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "UseWeaponDurability");

	Params::FortWeapon_UseWeaponDurability Parms{};

	Parms.DurabilityScale = DurabilityScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeapon.GetAlterations
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAlterationItemDefinition*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortAlterationItemDefinition*> AFortWeapon::GetAlterations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetAlterations");

	Params::FortWeapon_GetAlterations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetBulletsPerClip
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortWeapon::GetBulletsPerClip() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetBulletsPerClip");

	Params::FortWeapon_GetBulletsPerClip Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetChargePercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeapon::GetChargePercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetChargePercent");

	Params::FortWeapon_GetChargePercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetCoreAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortWeaponCoreAnimation                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortWeaponCoreAnimation AFortWeapon::GetCoreAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetCoreAnimation");

	Params::FortWeapon_GetCoreAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetCurrentMaxChargePercent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeapon::GetCurrentMaxChargePercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetCurrentMaxChargePercent");

	Params::FortWeapon_GetCurrentMaxChargePercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetDamageStartLocation
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         AimDir                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortWeapon::GetDamageStartLocation(struct FVector* AimDir) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetDamageStartLocation");

	Params::FortWeapon_GetDamageStartLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AimDir != nullptr)
		*AimDir = std::move(Parms.AimDir);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetLocalMagazineAmmoCount
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortWeapon::GetLocalMagazineAmmoCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetLocalMagazineAmmoCount");

	Params::FortWeapon_GetLocalMagazineAmmoCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetLocalRemainingAmmo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortWeapon::GetLocalRemainingAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetLocalRemainingAmmo");

	Params::FortWeapon_GetLocalRemainingAmmo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetMagazineAmmoCount
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortWeapon::GetMagazineAmmoCount() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetMagazineAmmoCount");

	Params::FortWeapon_GetMagazineAmmoCount Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetRange
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeapon::GetRange() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetRange");

	Params::FortWeapon_GetRange Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetReloadProgress
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeapon::GetReloadProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetReloadProgress");

	Params::FortWeapon_GetReloadProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetReloadTime
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeapon::GetReloadTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetReloadTime");

	Params::FortWeapon_GetReloadTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetRemainingAmmo
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortWeapon::GetRemainingAmmo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetRemainingAmmo");

	Params::FortWeapon_GetRemainingAmmo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.GetReticleColor
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FColor                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FColor AFortWeapon::GetReticleColor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "GetReticleColor");

	Params::FortWeapon_GetReticleColor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeapon.IsReloading
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortWeapon::IsReloading() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeapon", "IsReloading");

	Params::FortWeapon_IsReloading Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDecoTool.OnCarriedActorDestroyed
// (Final, Native, Private)

void AFortDecoTool::OnCarriedActorDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoTool", "OnCarriedActorDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoTool.OnRep_CarriedActor
// (Final, Native, Protected)

void AFortDecoTool::OnRep_CarriedActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoTool", "OnRep_CarriedActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoTool.OnRep_ItemDefinition
// (Final, Native, Protected)

void AFortDecoTool::OnRep_ItemDefinition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoTool", "OnRep_ItemDefinition");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoTool.ServerSpawnDeco
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class ABuildingSMActor*                 AttachedActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDecoTool::ServerSpawnDeco(const struct FVector& Location, const struct FRotator& Rotation, class ABuildingSMActor* AttachedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoTool", "ServerSpawnDeco");

	Params::FortDecoTool_ServerSpawnDeco Parms{};

	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);
	Parms.AttachedActor = AttachedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStorageVault.MoveItemFromStorage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostStorageVault::MoveItemFromStorage(class AFortPlayerControllerOutpost* Player, class UFortWorldItem* Item, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "MoveItemFromStorage");

	Params::BuildingOutpostStorageVault_MoveItemFromStorage Parms{};

	Parms.Player = Player;
	Parms.Item = Item;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStorageVault.MoveItemToStorage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItem*                   Item                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostStorageVault::MoveItemToStorage(class AFortPlayerControllerOutpost* Player, class UFortWorldItem* Item, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "MoveItemToStorage");

	Params::BuildingOutpostStorageVault_MoveItemToStorage Parms{};

	Parms.Player = Player;
	Parms.Item = Item;
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStorageVault.GetMaxSlotsNum
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostStorageVault::GetMaxSlotsNum(class AFortPlayerControllerOutpost* Player) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "GetMaxSlotsNum");

	Params::BuildingOutpostStorageVault_GetMaxSlotsNum Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostStorageVault.GetOccupiedSlotsNum
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingOutpostStorageVault::GetOccupiedSlotsNum(class AFortPlayerControllerOutpost* Player) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "GetOccupiedSlotsNum");

	Params::BuildingOutpostStorageVault_GetOccupiedSlotsNum Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostStorageVault.GetPlayerItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortInventoryFilter                    InventoryFilter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SearchFilter                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UFortItem*>                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortItem*> ABuildingOutpostStorageVault::GetPlayerItems(class AFortPlayerControllerOutpost* Player, EFortInventoryFilter InventoryFilter, const class FString& SearchFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "GetPlayerItems");

	Params::BuildingOutpostStorageVault_GetPlayerItems Parms{};

	Parms.Player = Player;
	Parms.InventoryFilter = InventoryFilter;
	Parms.SearchFilter = std::move(SearchFilter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostStorageVault.GetStoredItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortInventoryFilter                    InventoryFilter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    SearchFilter                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UFortItem*>                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortItem*> ABuildingOutpostStorageVault::GetStoredItems(class AFortPlayerControllerOutpost* Player, EFortInventoryFilter InventoryFilter, const class FString& SearchFilter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStorageVault", "GetStoredItems");

	Params::BuildingOutpostStorageVault_GetStoredItems Parms{};

	Parms.Player = Player;
	Parms.InventoryFilter = InventoryFilter;
	Parms.SearchFilter = std::move(SearchFilter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameState.HandleSharedInventoryUpdate
// (Native, Protected)

void AFortGameState::HandleSharedInventoryUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "HandleSharedInventoryUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_CurrentWUID
// (Native, Protected)

void AFortGameState::OnRep_CurrentWUID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_CurrentWUID");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_DayPhaseHandler
// (Native, Protected)

void AFortGameState::OnRep_DayPhaseHandler()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_DayPhaseHandler");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_FeedbackManager
// (Final, Native, Protected)

void AFortGameState::OnRep_FeedbackManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_FeedbackManager");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_GameplayState
// (Native, Protected)

void AFortGameState::OnRep_GameplayState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_GameplayState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_MissionManager
// (Final, Native, Protected)

void AFortGameState::OnRep_MissionManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_MissionManager");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.OnRep_WorldManager
// (Native, Protected)

void AFortGameState::OnRep_WorldManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "OnRep_WorldManager");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameState.GetDayPhaseHandler
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortDayNightLightingAndFog*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortDayNightLightingAndFog* AFortGameState::GetDayPhaseHandler() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameState", "GetDayPhaseHandler");

	Params::FortGameState_GetDayPhaseHandler Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.BlueprintOnBuilt
// (Event, Public, BlueprintEvent)

void ABuildingOutpostStormshieldUpgrade::BlueprintOnBuilt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "BlueprintOnBuilt");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.BlueprintOnDefended
// (Event, Public, BlueprintEvent)

void ABuildingOutpostStormshieldUpgrade::BlueprintOnDefended()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "BlueprintOnDefended");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.Build
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerControllerOutpost*     InBuildingPlayer                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingOutpostStormshieldUpgrade::Build(class AFortPlayerControllerOutpost* InBuildingPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "Build");

	Params::BuildingOutpostStormshieldUpgrade_Build Parms{};

	Parms.InBuildingPlayer = InBuildingPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.EmergencySetBuildFlag
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewBuild                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingOutpostStormshieldUpgrade::EmergencySetBuildFlag(bool bNewBuild)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "EmergencySetBuildFlag");

	Params::BuildingOutpostStormshieldUpgrade_EmergencySetBuildFlag Parms{};

	Parms.bNewBuild = bNewBuild;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.OnRep_bBuilt
// (Final, Native, Public)

void ABuildingOutpostStormshieldUpgrade::OnRep_bBuilt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "OnRep_bBuilt");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.OnRep_bDefended
// (Final, Native, Public)

void ABuildingOutpostStormshieldUpgrade::OnRep_bDefended()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "OnRep_bDefended");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.WasDefended
// (Final, Native, Public, BlueprintCallable)

void ABuildingOutpostStormshieldUpgrade::WasDefended()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "WasDefended");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingOutpostStormshieldUpgrade.CanBuild
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerControllerOutpost*     InBuildingPlayer                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLog                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingOutpostStormshieldUpgrade::CanBuild(class AFortPlayerControllerOutpost* InBuildingPlayer, bool bLog) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingOutpostStormshieldUpgrade", "CanBuild");

	Params::BuildingOutpostStormshieldUpgrade_CanBuild Parms{};

	Parms.InBuildingPlayer = InBuildingPlayer;
	Parms.bLog = bLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_ItemRegenMaxStack
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_ItemRegenMaxStack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_ItemRegenMaxStack");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_MaxStamina
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_MaxStamina()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_MaxStamina");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_SprintCost
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_SprintCost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_SprintCost");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_Stamina
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_Stamina()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_Stamina");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_StaminaCost
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_StaminaCost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_StaminaCost");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_StaminaRegenDelay
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_StaminaRegenDelay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_StaminaRegenDelay");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_StaminaRegenRate
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_StaminaRegenRate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_StaminaRegenRate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_WeaponRateOfFire
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_WeaponRateOfFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_WeaponRateOfFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAttrSet.OnRep_WeaponReloadSpeed
// (Final, Native, Public)

void UFortPlayerAttrSet::OnRep_WeaponReloadSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAttrSet", "OnRep_WeaponReloadSpeed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTooltip.GetNumericValue
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutVal                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetNumericValue(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, float* OutVal) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetNumericValue");

	Params::FortTooltip_GetNumericValue Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutVal != nullptr)
		*OutVal = Parms.OutVal;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltip.GetNumericValueInternal
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutVal                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetNumericValueInternal(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, float* OutVal) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetNumericValueInternal");

	Params::FortTooltip_GetNumericValueInternal Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutVal != nullptr)
		*OutVal = Parms.OutVal;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetTextForToken");

	Params::FortTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltip.GetTextForTokenInternal
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetTextForTokenInternal(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetTextForTokenInternal");

	Params::FortTooltip_GetTextForTokenInternal Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetTokenizedDescriptionText");

	Params::FortTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTooltip.GetTokenizedDescriptionTextInternal
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTooltip::GetTokenizedDescriptionTextInternal(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTooltip", "GetTokenizedDescriptionTextInternal");

	Params::FortTooltip_GetTokenizedDescriptionTextInternal Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinitionTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemDefinitionTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinitionTooltip", "GetTextForToken");

	Params::FortItemDefinitionTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortItemDefinitionTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortItemDefinitionTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortItemDefinitionTooltip", "GetTokenizedDescriptionText");

	Params::FortItemDefinitionTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorldItemDefinitionTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortWorldItemDefinitionTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorldItemDefinitionTooltip", "GetTextForToken");

	Params::FortWorldItemDefinitionTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWorldItemDefinitionTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortWorldItemDefinitionTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWorldItemDefinitionTooltip", "GetTokenizedDescriptionText");

	Params::FortWorldItemDefinitionTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.AddDamageComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              DamageComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingTrap::AddDamageComponent(class UPrimitiveComponent* DamageComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "AddDamageComponent");

	Params::BuildingTrap_AddDamageComponent Parms{};

	Parms.DamageComponent = DamageComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.AddTriggerComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              TriggerComponent                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingTrap::AddTriggerComponent(class UPrimitiveComponent* TriggerComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "AddTriggerComponent");

	Params::BuildingTrap_AddTriggerComponent Parms{};

	Parms.TriggerComponent = TriggerComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.AttemptRetrigger
// (Native, Public, BlueprintCallable)
// Parameters:
// float                                   Seconds                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingTrap::AttemptRetrigger(float Seconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "AttemptRetrigger");

	Params::BuildingTrap_AttemptRetrigger Parms{};

	Parms.Seconds = Seconds;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.FinishTrigger
// (Native, Public, BlueprintCallable)

void ABuildingTrap::FinishTrigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "FinishTrigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.GetArmTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetArmTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetArmTime");

	Params::BuildingTrap_GetArmTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetBuildTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetBuildTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetBuildTime");

	Params::BuildingTrap_GetBuildTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetCenter
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector ABuildingTrap::GetCenter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetCenter");

	Params::BuildingTrap_GetCenter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetReloadTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetReloadTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetReloadTime");

	Params::BuildingTrap_GetReloadTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.OnDestroy
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingTrap::OnDestroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnDestroy");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnFinishedBuilding
// (Event, Public, BlueprintEvent)

void ABuildingTrap::OnFinishedBuilding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnFinishedBuilding");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnInitAlteration
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UFortAlterationItemDefinition*    NewAlteration                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void ABuildingTrap::OnInitAlteration(class UFortAlterationItemDefinition* NewAlteration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnInitAlteration");

	Params::BuildingTrap_OnInitAlteration Parms{};

	Parms.NewAlteration = NewAlteration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingTrap.OnInitCosmeticAlterations
// (Event, Protected, BlueprintEvent)
// Parameters:
// const struct FFortCosmeticModification& CosmeticMod                                            (Parm, NativeAccessSpecifierPublic)

void ABuildingTrap::OnInitCosmeticAlterations(const struct FFortCosmeticModification& CosmeticMod)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnInitCosmeticAlterations");

	Params::BuildingTrap_OnInitCosmeticAlterations Parms{};

	Parms.CosmeticMod = std::move(CosmeticMod);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingTrap.OnOutOfDurability
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingTrap::OnOutOfDurability()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnOutOfDurability");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnPlaced
// (Event, Public, BlueprintEvent)

void ABuildingTrap::OnPlaced()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnPlaced");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnReloadBegin
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingTrap::OnReloadBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnReloadBegin");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnReloadEnd
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void ABuildingTrap::OnReloadEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnReloadEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.BuildingTrap.OnRep_AttachedTo
// (Native, Protected)

void ABuildingTrap::OnRep_AttachedTo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnRep_AttachedTo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.OnRep_ReplicatedAppliedAlterations
// (Native, Protected)

void ABuildingTrap::OnRep_ReplicatedAppliedAlterations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "OnRep_ReplicatedAppliedAlterations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.OnTriggerTouch
// (Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void ABuildingTrap::OnTriggerTouch(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("BuildingTrap", "OnTriggerTouch");

	Params::BuildingTrap_OnTriggerTouch Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.TriggerIfAppropriate
// (BlueprintAuthorityOnly, Native, Protected, BlueprintCallable)

void ABuildingTrap::TriggerIfAppropriate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "TriggerIfAppropriate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTrap.BP_ShouldTrigger
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const TArray<class AActor*>&            TouchingActors                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingTrap::BP_ShouldTrigger(const TArray<class AActor*>& TouchingActors) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "BP_ShouldTrigger");

	Params::BuildingTrap_BP_ShouldTrigger Parms{};

	Parms.TouchingActors = std::move(TouchingActors);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetAlterations
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAlterationItemDefinition*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UFortAlterationItemDefinition*> ABuildingTrap::GetAlterations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetAlterations");

	Params::BuildingTrap_GetAlterations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetBuildingAttachedTo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABuildingSMActor*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingSMActor* ABuildingTrap::GetBuildingAttachedTo() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetBuildingAttachedTo");

	Params::BuildingTrap_GetBuildingAttachedTo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetDamageDelay
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetDamageDelay() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetDamageDelay");

	Params::BuildingTrap_GetDamageDelay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetDurabilityPercent
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetDurabilityPercent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetDurabilityPercent");

	Params::BuildingTrap_GetDurabilityPercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetFireDelay
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetFireDelay() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetFireDelay");

	Params::BuildingTrap_GetFireDelay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetFireLocationAndRotation
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform ABuildingTrap::GetFireLocationAndRotation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetFireLocationAndRotation");

	Params::BuildingTrap_GetFireLocationAndRotation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetMaxDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float ABuildingTrap::GetMaxDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetMaxDurability");

	Params::BuildingTrap_GetMaxDurability Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetTouchingDamageTargets
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortTargetFilter&         Filter                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> ABuildingTrap::GetTouchingDamageTargets(const struct FFortTargetFilter& Filter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetTouchingDamageTargets");

	Params::BuildingTrap_GetTouchingDamageTargets Parms{};

	Parms.Filter = std::move(Filter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.GetTrapLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 ABuildingTrap::GetTrapLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "GetTrapLevel");

	Params::BuildingTrap_GetTrapLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTrap.HasDurability
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool ABuildingTrap::HasDurability() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTrap", "HasDurability");

	Params::BuildingTrap_HasDurability Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.GetBulletShellFXTemplate
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UParticleSystem*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UParticleSystem* AFortWeaponRanged::GetBulletShellFXTemplate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "GetBulletShellFXTemplate");

	Params::FortWeaponRanged_GetBulletShellFXTemplate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.ShouldSpawnBulletShellFX
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortWeaponRanged::ShouldSpawnBulletShellFX()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "ShouldSpawnBulletShellFX");

	Params::FortWeaponRanged_ShouldSpawnBulletShellFX Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.GetMuzzleLocation
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortWeaponRanged::GetMuzzleLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "GetMuzzleLocation");

	Params::FortWeaponRanged_GetMuzzleLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.GetMuzzleSocketTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AFortWeaponRanged::GetMuzzleSocketTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "GetMuzzleSocketTransform");

	Params::FortWeaponRanged_GetMuzzleSocketTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.GetTimeToNextFire
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortWeaponRanged::GetTimeToNextFire() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "GetTimeToNextFire");

	Params::FortWeaponRanged_GetTimeToNextFire Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeaponRanged.ShouldDisplayAmmoCounter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortWeaponRanged::ShouldDisplayAmmoCounter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeaponRanged", "ShouldDisplayAmmoCounter");

	Params::FortWeaponRanged_ShouldDisplayAmmoCounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeap_WannaGun.OnRep_LastHitActorClass
// (Final, Native, Private)

void AFortWeap_WannaGun::OnRep_LastHitActorClass()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeap_WannaGun", "OnRep_LastHitActorClass");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingWall.OnRep_bDoorCollisionDisabled
// (Native, Protected)

void ABuildingWall::OnRep_bDoorCollisionDisabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingWall", "OnRep_bDoorCollisionDisabled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingWall.OnRep_bDoorOpen
// (Native, Protected)

void ABuildingWall::OnRep_bDoorOpen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingWall", "OnRep_bDoorOpen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeartBase.AssociateWithTheMission
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortMission*                     KeepMission                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepHeartBase::AssociateWithTheMission(class AFortMission* KeepMission)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "AssociateWithTheMission");

	Params::KeepHeartBase_AssociateWithTheMission Parms{};

	Parms.KeepMission = KeepMission;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeartBase.IsKeepLoaded
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeartBase::IsKeepLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "IsKeepLoaded");

	Params::KeepHeartBase_IsKeepLoaded Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeartBase.IsKeepOwner
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AFortPlayerController*      FortPC                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeartBase::IsKeepOwner(const class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "IsKeepOwner");

	Params::KeepHeartBase_IsKeepOwner Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeartBase.LoadUserKeep
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepHeartBase::LoadUserKeep(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "LoadUserKeep");

	Params::KeepHeartBase_LoadUserKeep Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeartBase.ResetUserKeep
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeartBase::ResetUserKeep(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "ResetUserKeep");

	Params::KeepHeartBase_ResetUserKeep Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeartBase.SaveUserKeep
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeartBase::SaveUserKeep(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "SaveUserKeep");

	Params::KeepHeartBase_SaveUserKeep Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeartBase.SetAllowLooting
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAllowed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKeepHeartBase::SetAllowLooting(bool bAllowed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeartBase", "SetAllowLooting");

	Params::KeepHeartBase_SetAllowLooting Parms{};

	Parms.bAllowed = bAllowed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKeepEventInfo.GetWave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKeepEventWaveData         ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FKeepEventWaveData UFortKeepEventInfo::GetWave(int32 INDEX)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepEventInfo", "GetWave");

	Params::FortKeepEventInfo_GetWave Parms{};

	Parms.INDEX = INDEX;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepEventInfo.NumberOfWaves
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortKeepEventInfo::NumberOfWaves()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepEventInfo", "NumberOfWaves");

	Params::FortKeepEventInfo_NumberOfWaves Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepEventList.GetEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Idx                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKeepEventInfo                   ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FKeepEventInfo UFortKeepEventList::GetEvent(int32 Idx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepEventList", "GetEvent");

	Params::FortKeepEventList_GetEvent Parms{};

	Parms.Idx = Idx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepEventList.GetEventDescription
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Idx                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortKeepEventList::GetEventDescription(int32 Idx)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepEventList", "GetEventDescription");

	Params::FortKeepEventList_GetEventDescription Parms{};

	Parms.Idx = Idx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepDefenseManager.GetEventDescriptionFromTheList
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortKeepEventList*               EventList                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   EventNumber                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortKeepDefenseManager::GetEventDescriptionFromTheList(class UFortKeepEventList* EventList, int32 EventNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "GetEventDescriptionFromTheList");

	Params::FortKeepDefenseManager_GetEventDescriptionFromTheList Parms{};

	Parms.EventList = EventList;
	Parms.EventNumber = EventNumber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepDefenseManager.GetNumberAliveEnemies
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortKeepDefenseManager::GetNumberAliveEnemies()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "GetNumberAliveEnemies");

	Params::FortKeepDefenseManager_GetNumberAliveEnemies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepDefenseManager.GetWaveDescription
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortKeepDefenseManager::GetWaveDescription()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "GetWaveDescription");

	Params::FortKeepDefenseManager_GetWaveDescription Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepDefenseManager.GoToNextWave
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortKeepDefenseManager::GoToNextWave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "GoToNextWave");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKeepDefenseManager.SkipWarmup
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortKeepDefenseManager::SkipWarmup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "SkipWarmup");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKeepDefenseManager.StartAIEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAISpawnGroupProgressionInfo* SpawnGroupProgressionInfo                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   EncounterDifficultyLevel                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AliveMultiplier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* AFortKeepDefenseManager::StartAIEncounter(TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate, class AActor* TargetActor, class UFortAISpawnGroupProgressionInfo* SpawnGroupProgressionInfo, int32 ActivationDelay, int32 EncounterDifficultyLevel, float AliveMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "StartAIEncounter");

	Params::FortKeepDefenseManager_StartAIEncounter Parms{};

	Parms.EncounterTemplate = EncounterTemplate;
	Parms.TargetActor = TargetActor;
	Parms.SpawnGroupProgressionInfo = SpawnGroupProgressionInfo;
	Parms.ActivationDelay = ActivationDelay;
	Parms.EncounterDifficultyLevel = EncounterDifficultyLevel;
	Parms.AliveMultiplier = AliveMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKeepDefenseManager.StartEvent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortKeepEventInfo*               EventTemplate                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   DifficultyLevelOffset                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortKeepDefenseManager::StartEvent(class UFortKeepEventInfo* EventTemplate, int32 DifficultyLevelOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "StartEvent");

	Params::FortKeepDefenseManager_StartEvent Parms{};

	Parms.EventTemplate = EventTemplate;
	Parms.DifficultyLevelOffset = DifficultyLevelOffset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKeepDefenseManager.StartEventFromList
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortKeepEventList*               EventList                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   EventNumber                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortKeepDefenseManager::StartEventFromList(class UFortKeepEventList* EventList, int32 EventNumber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "StartEventFromList");

	Params::FortKeepDefenseManager_StartEventFromList Parms{};

	Parms.EventList = EventList;
	Parms.EventNumber = EventNumber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKeepDefenseManager.StopEvent
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortKeepDefenseManager::StopEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortKeepDefenseManager", "StopEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.ApplyPreferredDisplayState
// (Final, Native, Public)

void AMyTownBuildingActor::ApplyPreferredDisplayState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "ApplyPreferredDisplayState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.CreateUMGCollectWidget
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UNativeWidgetHost*                InNativeWidgetHost                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AMyTownBuildingActor::CreateUMGCollectWidget(class UNativeWidgetHost* InNativeWidgetHost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "CreateUMGCollectWidget");

	Params::MyTownBuildingActor_CreateUMGCollectWidget Parms{};

	Parms.InNativeWidgetHost = InNativeWidgetHost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownBuildingActor.OnBuildingClicked
// (Final, Native, Public)

void AMyTownBuildingActor::OnBuildingClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "OnBuildingClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.OnMouseOverBegin
// (Final, Native, Protected)

void AMyTownBuildingActor::OnMouseOverBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "OnMouseOverBegin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.OnMouseOverEnd
// (Final, Native, Protected)

void AMyTownBuildingActor::OnMouseOverEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "OnMouseOverEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.OnMyTownBuildingCustomDisplayChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EMyTownBuildingActorDisplayState        NewDisplayState                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMyTownBuildingActor::OnMyTownBuildingCustomDisplayChanged(EMyTownBuildingActorDisplayState NewDisplayState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "OnMyTownBuildingCustomDisplayChanged");

	Params::MyTownBuildingActor_OnMyTownBuildingCustomDisplayChanged Parms{};

	Parms.NewDisplayState = NewDisplayState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.MyTownBuildingActor.SetBuildingTemplateId
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InBuildingTemplateId                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMyTownBuildingActor::SetBuildingTemplateId(const class FString& InBuildingTemplateId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "SetBuildingTemplateId");

	Params::MyTownBuildingActor_SetBuildingTemplateId Parms{};

	Parms.InBuildingTemplateId = std::move(InBuildingTemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.SetCustomDisplayState
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// EMyTownBuildingActorDisplayState        NewDisplayState                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AMyTownBuildingActor::SetCustomDisplayState(EMyTownBuildingActorDisplayState NewDisplayState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "SetCustomDisplayState");

	Params::MyTownBuildingActor_SetCustomDisplayState Parms{};

	Parms.NewDisplayState = NewDisplayState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.MyTownBuildingActor.ShouldShowBang
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AMyTownBuildingActor::ShouldShowBang()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "ShouldShowBang");

	Params::MyTownBuildingActor_ShouldShowBang Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownBuildingActor.GetCustomDisplayActors
// (RequiredAPI, Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<class ABuildingActor*>           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ABuildingActor*> AMyTownBuildingActor::GetCustomDisplayActors() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "GetCustomDisplayActors");

	Params::MyTownBuildingActor_GetCustomDisplayActors Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.MyTownBuildingActor.GetCustomDisplayState
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EMyTownBuildingActorDisplayState        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EMyTownBuildingActorDisplayState AMyTownBuildingActor::GetCustomDisplayState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("MyTownBuildingActor", "GetCustomDisplayState");

	Params::MyTownBuildingActor_GetCustomDisplayState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStateZone.GetUIMapManager
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortInGameMapManager*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortInGameMapManager* AFortGameStateZone::GetUIMapManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "GetUIMapManager");

	Params::FortGameStateZone_GetUIMapManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStateZone.OnRep_PlayerStructuresChanged
// (Native, Public)

void AFortGameStateZone::OnRep_PlayerStructuresChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "OnRep_PlayerStructuresChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStateZone.OnRep_TheaterNameUpdated
// (Final, Native, Protected)

void AFortGameStateZone::OnRep_TheaterNameUpdated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "OnRep_TheaterNameUpdated");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStateZone.OnRep_UIMapManager
// (Final, Native, Protected)

void AFortGameStateZone::OnRep_UIMapManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "OnRep_UIMapManager");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStateZone.ServerFireAIDirectorEvent
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EFortAIDirectorEvent                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventTarget                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   EventMultiplier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortGameStateZone::ServerFireAIDirectorEvent(EFortAIDirectorEvent Event, class UObject* EventSource, class UObject* EventTarget, float EventMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "ServerFireAIDirectorEvent");

	Params::FortGameStateZone_ServerFireAIDirectorEvent Parms{};

	Parms.Event = Event;
	Parms.EventSource = EventSource;
	Parms.EventTarget = EventTarget;
	Parms.EventMultiplier = EventMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStateZone.GetGameDifficulty
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortGameStateZone::GetGameDifficulty() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateZone", "GetGameDifficulty");

	Params::FortGameStateZone_GetGameDifficulty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStateOutpost.SetGameDifficultyRow
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       GameDifficultyInfo                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortGameStateOutpost::SetGameDifficultyRow(const struct FDataTableRowHandle& GameDifficultyInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateOutpost", "SetGameDifficultyRow");

	Params::FortGameStateOutpost_SetGameDifficultyRow Parms{};

	Parms.GameDifficultyInfo = std::move(GameDifficultyInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.DelayedVoteSuccess
// (Final, Native, Public)

void AKeepHeart::DelayedVoteSuccess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "DelayedVoteSuccess");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.DestroyNonPermaniteStructures
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeart::DestroyNonPermaniteStructures()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "DestroyNonPermaniteStructures");

	Params::KeepHeart_DestroyNonPermaniteStructures Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetAveragePermaniteLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKeepHeart::GetAveragePermaniteLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetAveragePermaniteLevel");

	Params::KeepHeart_GetAveragePermaniteLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetPermaniteStructureLimit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeepHeart::GetPermaniteStructureLimit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetPermaniteStructureLimit");

	Params::KeepHeart_GetPermaniteStructureLimit Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetPermaniteStructureNumber
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeepHeart::GetPermaniteStructureNumber()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetPermaniteStructureNumber");

	Params::KeepHeart_GetPermaniteStructureNumber Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetUpgradeAllPermaniteCost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bQuickUpgrade                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeepHeart::GetUpgradeAllPermaniteCost(class AFortPlayerController* FortPC, bool bQuickUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetUpgradeAllPermaniteCost");

	Params::KeepHeart_GetUpgradeAllPermaniteCost Parms{};

	Parms.FortPC = FortPC;
	Parms.bQuickUpgrade = bQuickUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetWorldStreamingInProgress
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKeepHeart::GetWorldStreamingInProgress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetWorldStreamingInProgress");

	Params::KeepHeart_GetWorldStreamingInProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.HandleVoteComplete
// (Final, Native, Public)
// Parameters:
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKeepHeart::HandleVoteComplete(bool bResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "HandleVoteComplete");

	Params::KeepHeart_HandleVoteComplete Parms{};

	Parms.bResult = bResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.IsWorldStreamedIn
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeart::IsWorldStreamedIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "IsWorldStreamedIn");

	Params::KeepHeart_IsWorldStreamedIn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.IsWorldStreamingIn
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeart::IsWorldStreamingIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "IsWorldStreamingIn");

	Params::KeepHeart_IsWorldStreamingIn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.NotifyEncounterEnded
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIEncounterInfo*             EndedEncounter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepHeart::NotifyEncounterEnded(class UFortAIEncounterInfo* EndedEncounter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "NotifyEncounterEnded");

	Params::KeepHeart_NotifyEncounterEnded Parms{};

	Parms.EndedEncounter = EndedEncounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.NotifyEncounterStarted
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIEncounterInfo*             StartedEncounter                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKeepHeart::NotifyEncounterStarted(class UFortAIEncounterInfo* StartedEncounter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "NotifyEncounterStarted");

	Params::KeepHeart_NotifyEncounterStarted Parms{};

	Parms.StartedEncounter = StartedEncounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.OnDefenseLevelChanged
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::OnDefenseLevelChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "OnDefenseLevelChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.OnVoteComplete
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bResult                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKeepHeart::OnVoteComplete(bool bResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "OnVoteComplete");

	Params::KeepHeart_OnVoteComplete Parms{};

	Parms.bResult = bResult;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.KeepHeart.OnWorldStreamedIn
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AKeepHeart::OnWorldStreamedIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "OnWorldStreamedIn");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.KeepHeart.ResetContainers
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::ResetContainers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "ResetContainers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.RestoreContainers
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::RestoreContainers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "RestoreContainers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.RestoreKeepHealth
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::RestoreKeepHealth()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "RestoreKeepHealth");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.SetPermaniteAvailability
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAvailable                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKeepHeart::SetPermaniteAvailability(bool bAvailable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "SetPermaniteAvailability");

	Params::KeepHeart_SetPermaniteAvailability Parms{};

	Parms.bAvailable = bAvailable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.StartVote
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      VoteText                                               (Parm, NativeAccessSpecifierPublic)
// const class FText&                      YesText                                                (Parm, NativeAccessSpecifierPublic)
// const class FText&                      NoText                                                 (Parm, NativeAccessSpecifierPublic)
// float                                   PercentageToPass                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSkipIfOnePlayerOnly                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKeepHeart::StartVote(const class FText& VoteText, const class FText& YesText, const class FText& NoText, float PercentageToPass, bool bSkipIfOnePlayerOnly)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "StartVote");

	Params::KeepHeart_StartVote Parms{};

	Parms.VoteText = std::move(VoteText);
	Parms.YesText = std::move(YesText);
	Parms.NoText = std::move(NoText);
	Parms.PercentageToPass = PercentageToPass;
	Parms.bSkipIfOnePlayerOnly = bSkipIfOnePlayerOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.StreamInWorld
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::StreamInWorld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "StreamInWorld");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.StreamOutWorld
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AKeepHeart::StreamOutWorld()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "StreamOutWorld");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.KeepHeart.UpgradeAllPermaniteStructures
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bQuickUpgrade                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeart::UpgradeAllPermaniteStructures(class AFortPlayerController* FortPC, bool bQuickUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "UpgradeAllPermaniteStructures");

	Params::KeepHeart_UpgradeAllPermaniteStructures Parms{};

	Parms.FortPC = FortPC;
	Parms.bQuickUpgrade = bQuickUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.GetDefenseLevel
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKeepHeart::GetDefenseLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "GetDefenseLevel");

	Params::KeepHeart_GetDefenseLevel Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.KeepHeart.IsDefenseActive
// (Event, Public, BlueprintEvent, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AKeepHeart::IsDefenseActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KeepHeart", "IsDefenseActive");

	Params::KeepHeart_IsDefenseActive Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorHeart.TravelToNewWorld
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortTheaterInfo*                 NewTheater                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AManorHeart::TravelToNewWorld(class UFortTheaterInfo* NewTheater)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorHeart", "TravelToNewWorld");

	Params::ManorHeart_TravelToNewWorld Parms{};

	Parms.NewTheater = NewTheater;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthBarComponent.OnRep_DisplayText
// (Final, Native, Protected)

void UFortHealthBarComponent::OnRep_DisplayText()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthBarComponent", "OnRep_DisplayText");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthBarComponent.OnRep_IsVisible
// (Final, Native, Protected)

void UFortHealthBarComponent::OnRep_IsVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthBarComponent", "OnRep_IsVisible");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthBarComponent.SetHealthBarDisplayText
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      NewDisplayText                                         (Parm, NativeAccessSpecifierPublic)

void UFortHealthBarComponent::SetHealthBarDisplayText(const class FText& NewDisplayText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthBarComponent", "SetHealthBarDisplayText");

	Params::FortHealthBarComponent_SetHealthBarDisplayText Parms{};

	Parms.NewDisplayText = std::move(NewDisplayText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthBarComponent.SetHealthBarVisibility
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewVisibleState                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortHealthBarComponent::SetHealthBarVisibility(bool bNewVisibleState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthBarComponent", "SetHealthBarVisibility");

	Params::FortHealthBarComponent_SetHealthBarVisibility Parms{};

	Parms.bNewVisibleState = bNewVisibleState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHealthBarComponent.SetHealthBarWidgetVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsVisible                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortHealthBarComponent::SetHealthBarWidgetVisibility(bool bIsVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHealthBarComponent", "SetHealthBarWidgetVisibility");

	Params::FortHealthBarComponent_SetHealthBarWidgetVisibility Parms{};

	Parms.bIsVisible = bIsVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.VelocityGridData.AddPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   SplinePoint                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   PointEnvelope                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PointStrength                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UVelocityGridData::AddPoint(const struct FVector& SplinePoint, float PointEnvelope, float PointStrength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VelocityGridData", "AddPoint");

	Params::VelocityGridData_AddPoint Parms{};

	Parms.SplinePoint = std::move(SplinePoint);
	Parms.PointEnvelope = PointEnvelope;
	Parms.PointStrength = PointStrength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.VelocityGridData.RebuildData
// (Final, Native, Public, BlueprintCallable)

void UVelocityGridData::RebuildData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("VelocityGridData", "RebuildData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayTagVolumeInterface.ApplyTags
// (Native, Public)

void IFortGameplayTagVolumeInterface::ApplyTags()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayTagVolumeInterface", "ApplyTags");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.WorldMapPinManager.CreateWorldMapPin
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   TheaterIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AWorldMapPin*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AWorldMapPin* AWorldMapPinManager::CreateWorldMapPin(int32 TheaterIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("WorldMapPinManager", "CreateWorldMapPin");

	Params::WorldMapPinManager_CreateWorldMapPin Parms{};

	Parms.TheaterIndex = TheaterIndex;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingConnectivityComponent.Connect
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortConnectionData&       NewConnection                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UBuildingConnectivityComponent::Connect(const struct FFortConnectionData& NewConnection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "Connect");

	Params::BuildingConnectivityComponent_Connect Parms{};

	Parms.NewConnection = std::move(NewConnection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.Disconnect
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortConnectionData&       NewDisconnection                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UBuildingConnectivityComponent::Disconnect(const struct FFortConnectionData& NewDisconnection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "Disconnect");

	Params::BuildingConnectivityComponent_Disconnect Parms{};

	Parms.NewDisconnection = std::move(NewDisconnection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.DisconnectAll
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UBuildingConnectivityComponent::DisconnectAll()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "DisconnectAll");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.DrawDebugData
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void UBuildingConnectivityComponent::DrawDebugData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "DrawDebugData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.K2_IsPowered
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UBuildingConnectivityComponent::K2_IsPowered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "K2_IsPowered");

	Params::BuildingConnectivityComponent_K2_IsPowered Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingConnectivityComponent.OnPlaced
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UBuildingConnectivityComponent::OnPlaced()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "OnPlaced");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.OnRep_bIsPowered
// (Native, Protected)

void UBuildingConnectivityComponent::OnRep_bIsPowered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "OnRep_bIsPowered");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.OnRep_bIsProvidingPower
// (Native, Protected)

void UBuildingConnectivityComponent::OnRep_bIsProvidingPower()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "OnRep_bIsProvidingPower");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.OnRep_Connections
// (Native, Protected)

void UBuildingConnectivityComponent::OnRep_Connections()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "OnRep_Connections");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.SetAllowConnections
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInAllowConnections                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBuildingConnectivityComponent::SetAllowConnections(bool bInAllowConnections)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "SetAllowConnections");

	Params::BuildingConnectivityComponent_SetAllowConnections Parms{};

	Parms.bInAllowConnections = bInAllowConnections;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.SetIsProvidingPower
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewIsProvidingPower                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UBuildingConnectivityComponent::SetIsProvidingPower(bool bNewIsProvidingPower)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "SetIsProvidingPower");

	Params::BuildingConnectivityComponent_SetIsProvidingPower Parms{};

	Parms.bNewIsProvidingPower = bNewIsProvidingPower;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingConnectivityComponent.CanConnectTo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABuildingSMActor*                 TestActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UBuildingConnectivityComponent::CanConnectTo(class ABuildingSMActor* TestActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "CanConnectTo");

	Params::BuildingConnectivityComponent_CanConnectTo Parms{};

	Parms.TestActor = TestActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingConnectivityComponent.IsConnectedTo
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABuildingSMActor*                 TestActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UBuildingConnectivityComponent::IsConnectedTo(class ABuildingSMActor* TestActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityComponent", "IsConnectedTo");

	Params::BuildingConnectivityComponent_IsConnectedTo Parms{};

	Parms.TestActor = TestActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingConnectivityEffect.OnConnect
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FTransform&                T1                                                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                T2                                                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void ABuildingConnectivityEffect::OnConnect(const struct FTransform& T1, const struct FTransform& T2)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityEffect", "OnConnect");

	Params::BuildingConnectivityEffect_OnConnect Parms{};

	Parms.T1 = std::move(T1);
	Parms.T2 = std::move(T2);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.BuildingConnectivityEffect.OnDisconnect
// (Event, Public, BlueprintEvent)

void ABuildingConnectivityEffect::OnDisconnect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingConnectivityEffect", "OnDisconnect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortInGameMapManager.ApplyShowFlags
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USceneCaptureComponent*           SceneCaptureComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortInGameMapManager::ApplyShowFlags(class USceneCaptureComponent* SceneCaptureComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortInGameMapManager", "ApplyShowFlags");

	Params::FortInGameMapManager_ApplyShowFlags Parms{};

	Parms.SceneCaptureComponent = SceneCaptureComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortInGameMapManager.PaintOnFog
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   WorldCoords                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortInGameMapManager::PaintOnFog(const struct FVector& WorldCoords)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortInGameMapManager", "PaintOnFog");

	Params::FortInGameMapManager_PaintOnFog Parms{};

	Parms.WorldCoords = std::move(WorldCoords);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseBuilding.ClearBang
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseBuilding::ClearBang()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "ClearBang");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseBuilding.OnBuildingChangedInternal
// (Final, Native, Private)
// Parameters:
// bool                                    bItemChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAmmoChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIngredientsChanged                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UHomeBaseBuilding::OnBuildingChangedInternal(bool bItemChanged, bool bAmmoChanged, bool bIngredientsChanged)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "OnBuildingChangedInternal");

	Params::HomeBaseBuilding_OnBuildingChangedInternal Parms{};

	Parms.bItemChanged = bItemChanged;
	Parms.bAmmoChanged = bAmmoChanged;
	Parms.bIngredientsChanged = bIngredientsChanged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseBuilding.Upgrade
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseBuilding::Upgrade()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "Upgrade");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseBuilding.GetAbilityKitForLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   InLevel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityKit*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityKit* UHomeBaseBuilding::GetAbilityKitForLevel(int32 InLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetAbilityKitForLevel");

	Params::HomeBaseBuilding_GetAbilityKitForLevel Parms{};

	Parms.InLevel = InLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetAbilityKits
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortAbilityKit*>*         AbilityKits                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UHomeBaseBuilding::GetAbilityKits(TArray<class UFortAbilityKit*>* AbilityKits) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetAbilityKits");

	Params::HomeBaseBuilding_GetAbilityKits Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AbilityKits != nullptr)
		*AbilityKits = std::move(Parms.AbilityKits);
}


// Function FortniteGame.HomeBaseBuilding.GetCurrentBonuses
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UBuildingLevelGameplayEffectInfo*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UBuildingLevelGameplayEffectInfo*> UHomeBaseBuilding::GetCurrentBonuses() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetCurrentBonuses");

	Params::HomeBaseBuilding_GetCurrentBonuses Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMyTownBuildingItem*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMyTownBuildingItem* UHomeBaseBuilding::GetItem() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetItem");

	Params::HomeBaseBuilding_GetItem Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetMaxLevelBonuses
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UBuildingLevelGameplayEffectInfo*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UBuildingLevelGameplayEffectInfo*> UHomeBaseBuilding::GetMaxLevelBonuses() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetMaxLevelBonuses");

	Params::HomeBaseBuilding_GetMaxLevelBonuses Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetNextBonuses
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UBuildingLevelGameplayEffectInfo*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UBuildingLevelGameplayEffectInfo*> UHomeBaseBuilding::GetNextBonuses() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetNextBonuses");

	Params::HomeBaseBuilding_GetNextBonuses Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetTeammatesRatingAddition
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FUniqueNetIdRepl&          TeammatesAccountId                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UHomeBaseBuilding::GetTeammatesRatingAddition(const struct FUniqueNetIdRepl& TeammatesAccountId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetTeammatesRatingAddition");

	Params::HomeBaseBuilding_GetTeammatesRatingAddition Parms{};

	Parms.TeammatesAccountId = std::move(TeammatesAccountId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.GetUpgradeRequirements
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBuildingUpgradeRequirementsForLevelReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FBuildingUpgradeRequirementsForLevel UHomeBaseBuilding::GetUpgradeRequirements() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "GetUpgradeRequirements");

	Params::HomeBaseBuilding_GetUpgradeRequirements Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseBuilding.ShouldShowBang
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UHomeBaseBuilding::ShouldShowBang() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseBuilding", "ShouldShowBang");

	Params::HomeBaseBuilding_ShouldShowBang Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseMainBuilding.OnBuildingGameplayEffectsChanged
// (Final, Native, Private)

void UHomeBaseMainBuilding::OnBuildingGameplayEffectsChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseMainBuilding", "OnBuildingGameplayEffectsChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseMainBuilding.OnSubBuildingChanged
// (Final, Native, Private)

void UHomeBaseMainBuilding::OnSubBuildingChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseMainBuilding", "OnSubBuildingChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseMainBuilding.OnWorkersChangedInternal
// (Final, Native, Private)

void UHomeBaseMainBuilding::OnWorkersChangedInternal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseMainBuilding", "OnWorkersChangedInternal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseMainBuilding.GetEffects
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UAccumulatedGameplayEffectInfo*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UAccumulatedGameplayEffectInfo*> UHomeBaseMainBuilding::GetEffects() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseMainBuilding", "GetEffects");

	Params::HomeBaseMainBuilding_GetEffects Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseMainBuilding.ShouldShow
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UHomeBaseMainBuilding::ShouldShow() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseMainBuilding", "ShouldShow");

	Params::HomeBaseMainBuilding_ShouldShow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingEditModeSupport.OnSuccessfulMatchInteractComplete
// (Native, Public)

void UBuildingEditModeSupport::OnSuccessfulMatchInteractComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingEditModeSupport", "OnSuccessfulMatchInteractComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingEditModeSupport.OnSuccessfulMatchInteractParamUpdate
// (Native, Public)
// Parameters:
// float                                   NewInteractParamVal                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuildingEditModeSupport::OnSuccessfulMatchInteractParamUpdate(float NewInteractParamVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingEditModeSupport", "OnSuccessfulMatchInteractParamUpdate");

	Params::BuildingEditModeSupport_OnSuccessfulMatchInteractParamUpdate Parms{};

	Parms.NewInteractParamVal = NewInteractParamVal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingStructuralSupportSystem.GetBestBuildingTarget
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AActor*                           ObjectiveActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           AttackerActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBuildingValueRules&       ValueRules                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class ABuildingSMActor*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingSMActor* UBuildingStructuralSupportSystem::GetBestBuildingTarget(class AActor* ObjectiveActor, class AActor* AttackerActor, const struct FBuildingValueRules& ValueRules)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingStructuralSupportSystem", "GetBestBuildingTarget");

	Params::BuildingStructuralSupportSystem_GetBestBuildingTarget Parms{};

	Parms.ObjectiveActor = ObjectiveActor;
	Parms.AttackerActor = AttackerActor;
	Parms.ValueRules = std::move(ValueRules);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingStructuralSupportSystem.GetLogicalBuildingGroundSupportedActors
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   LogicalIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABuildingSMActor*>*        LogicalBuildingGroundSupportedActors                   (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBuildingStructuralSupportSystem::GetLogicalBuildingGroundSupportedActors(int32 LogicalIndex, TArray<class ABuildingSMActor*>* LogicalBuildingGroundSupportedActors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingStructuralSupportSystem", "GetLogicalBuildingGroundSupportedActors");

	Params::BuildingStructuralSupportSystem_GetLogicalBuildingGroundSupportedActors Parms{};

	Parms.LogicalIndex = LogicalIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LogicalBuildingGroundSupportedActors != nullptr)
		*LogicalBuildingGroundSupportedActors = std::move(Parms.LogicalBuildingGroundSupportedActors);
}


// Function FortniteGame.BuildingStructuralSupportSystem.K2_GetLogicalBuildingActors
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   LogicalIdx                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABuildingSMActor*>*        LogicalBuildingActors                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UBuildingStructuralSupportSystem::K2_GetLogicalBuildingActors(int32 LogicalIdx, TArray<class ABuildingSMActor*>* LogicalBuildingActors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingStructuralSupportSystem", "K2_GetLogicalBuildingActors");

	Params::BuildingStructuralSupportSystem_K2_GetLogicalBuildingActors Parms{};

	Parms.LogicalIdx = LogicalIdx;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LogicalBuildingActors != nullptr)
		*LogicalBuildingActors = std::move(Parms.LogicalBuildingActors);
}


// Function FortniteGame.BuildingStructuralSupportSystem.MakeBuildingValueRules
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   CellsAbove                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CellsBelow                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CellHorizontalRadius                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DistanceFromObjectiveWeight                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AttackWeight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StructuralWeight                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TrapWeight                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FBuildingValueRules              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FBuildingValueRules UBuildingStructuralSupportSystem::MakeBuildingValueRules(int32 CellsAbove, int32 CellsBelow, int32 CellHorizontalRadius, float DistanceFromObjectiveWeight, float AttackWeight, float StructuralWeight, float TrapWeight) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingStructuralSupportSystem", "MakeBuildingValueRules");

	Params::BuildingStructuralSupportSystem_MakeBuildingValueRules Parms{};

	Parms.CellsAbove = CellsAbove;
	Parms.CellsBelow = CellsBelow;
	Parms.CellHorizontalRadius = CellHorizontalRadius;
	Parms.DistanceFromObjectiveWeight = DistanceFromObjectiveWeight;
	Parms.AttackWeight = AttackWeight;
	Parms.StructuralWeight = StructuralWeight;
	Parms.TrapWeight = TrapWeight;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAlterableItem.GetNumberOfSlotsForAlterationType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAlteration                         AlterationType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortAlterableItem::GetNumberOfSlotsForAlterationType(EFortAlteration AlterationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAlterableItem", "GetNumberOfSlotsForAlterationType");

	Params::FortAlterableItem_GetNumberOfSlotsForAlterationType Parms{};

	Parms.AlterationType = AlterationType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSchematicItem.GetRequiredTeamLevelToCraft
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortSchematicItem::GetRequiredTeamLevelToCraft() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSchematicItem", "GetRequiredTeamLevelToCraft");

	Params::FortSchematicItem_GetRequiredTeamLevelToCraft Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSchematicItem.GetSchematicQuantityProduced
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortSchematicItem::GetSchematicQuantityProduced() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSchematicItem", "GetSchematicQuantityProduced");

	Params::FortSchematicItem_GetSchematicQuantityProduced Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSchematicItem.GetSchematicRequirements
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FSchematicRequirement>*   Requirements                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortSchematicItem::GetSchematicRequirements(TArray<struct FSchematicRequirement>* Requirements) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSchematicItem", "GetSchematicRequirements");

	Params::FortSchematicItem_GetSchematicRequirements Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Requirements != nullptr)
		*Requirements = std::move(Parms.Requirements);
}


// Function FortniteGame.BuildingTurretComponent.AttemptSetCurrentTarget
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NewTarget                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UBuildingTurretComponent::AttemptSetCurrentTarget(class AActor* NewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "AttemptSetCurrentTarget");

	Params::BuildingTurretComponent_AttemptSetCurrentTarget Parms{};

	Parms.NewTarget = NewTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTurretComponent.OnFiringTimer
// (Native, Protected)

void UBuildingTurretComponent::OnFiringTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "OnFiringTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.OnPerformTargetValidation
// (Native, Protected)

void UBuildingTurretComponent::OnPerformTargetValidation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "OnPerformTargetValidation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.OnRep_CurrentTarget
// (Native, Protected)
// Parameters:
// class AActor*                           OldTarget                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuildingTurretComponent::OnRep_CurrentTarget(class AActor* OldTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "OnRep_CurrentTarget");

	Params::BuildingTurretComponent_OnRep_CurrentTarget Parms{};

	Parms.OldTarget = OldTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.OnTargetingBeginOverlap
// (Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UBuildingTurretComponent::OnTargetingBeginOverlap(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("BuildingTurretComponent", "OnTargetingBeginOverlap");

	Params::BuildingTurretComponent_OnTargetingBeginOverlap Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.OnTargetingEndOverlap
// (Native, Protected)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuildingTurretComponent::OnTargetingEndOverlap(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "OnTargetingEndOverlap");

	Params::BuildingTurretComponent_OnTargetingEndOverlap Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.SetTargetingOverlapComponent
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              NewTargetingOverlapComponent                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuildingTurretComponent::SetTargetingOverlapComponent(class UPrimitiveComponent* NewTargetingOverlapComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "SetTargetingOverlapComponent");

	Params::BuildingTurretComponent_SetTargetingOverlapComponent Parms{};

	Parms.NewTargetingOverlapComponent = NewTargetingOverlapComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.BuildingTurretComponent.ChooseBestTarget
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// TArray<class AActor*>&                  InOutPotentialTargets                                  (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UBuildingTurretComponent::ChooseBestTarget(TArray<class AActor*>& InOutPotentialTargets) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "ChooseBestTarget");

	Params::BuildingTurretComponent_ChooseBestTarget Parms{};

	Parms.InOutPotentialTargets = std::move(InOutPotentialTargets);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	InOutPotentialTargets = std::move(Parms.InOutPotentialTargets);

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTurretComponent.IsValidTarget
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// class AActor*                           InTarget                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UBuildingTurretComponent::IsValidTarget(class AActor* InTarget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent", "IsValidTarget");

	Params::BuildingTurretComponent_IsValidTarget Parms{};

	Parms.InTarget = InTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.BuildingTurretComponent_MOBA.OnAllyHarmed
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InAllyActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InHarmingActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UBuildingTurretComponent_MOBA::OnAllyHarmed(class AActor* InAllyActor, class AActor* InHarmingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("BuildingTurretComponent_MOBA", "OnAllyHarmed");

	Params::BuildingTurretComponent_MOBA_OnAllyHarmed Parms{};

	Parms.InAllyActor = InAllyActor;
	Parms.InHarmingActor = InHarmingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.CustomCharacterPartAnimInstance.OnDayPhaseChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UCustomCharacterPartAnimInstance::OnDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "OnDayPhaseChanged");

	Params::CustomCharacterPartAnimInstance_OnDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.CustomCharacterPartAnimInstance.PreDestruction
// (Event, Public, BlueprintEvent)

void UCustomCharacterPartAnimInstance::PreDestruction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "PreDestruction");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.CustomCharacterPartAnimInstance.GetAssociatedPlayerPawn
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerPawn*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerPawn* UCustomCharacterPartAnimInstance::GetAssociatedPlayerPawn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "GetAssociatedPlayerPawn");

	Params::CustomCharacterPartAnimInstance_GetAssociatedPlayerPawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.CustomCharacterPartAnimInstance.GetCharacterPartType
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EFortCustomPartType               ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const EFortCustomPartType UCustomCharacterPartAnimInstance::GetCharacterPartType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "GetCharacterPartType");

	Params::CustomCharacterPartAnimInstance_GetCharacterPartType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.CustomCharacterPartAnimInstance.GetOwnerSkeletalMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* UCustomCharacterPartAnimInstance::GetOwnerSkeletalMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "GetOwnerSkeletalMeshComponent");

	Params::CustomCharacterPartAnimInstance_GetOwnerSkeletalMeshComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.CustomCharacterPartAnimInstance.GetPartSkeletalMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMeshComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMeshComponent* UCustomCharacterPartAnimInstance::GetPartSkeletalMeshComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CustomCharacterPartAnimInstance", "GetPartSkeletalMeshComponent");

	Params::CustomCharacterPartAnimInstance_GetPartSkeletalMeshComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSchematicItemDefinition.GetCraftingTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSchematicItemDefinition::GetCraftingTime(int32 Level) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSchematicItemDefinition", "GetCraftingTime");

	Params::FortSchematicItemDefinition_GetCraftingTime Parms{};

	Parms.Level = Level;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSchematicItemDefinition.GetCraftingTimeForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Level                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AFortPlayerPawn*            FortPawn                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortSchematicItemDefinition::GetCraftingTimeForCharacter(int32 Level, const class AFortPlayerPawn* FortPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSchematicItemDefinition", "GetCraftingTimeForCharacter");

	Params::FortSchematicItemDefinition_GetCraftingTimeForCharacter Parms{};

	Parms.Level = Level;
	Parms.FortPawn = FortPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilitySystemComponent.NetMulticast_RefreshActiveGameplayEffectCueEvents
// (Net, Native, Event, NetMulticast, Public)

void UFortAbilitySystemComponent::NetMulticast_RefreshActiveGameplayEffectCueEvents()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilitySystemComponent", "NetMulticast_RefreshActiveGameplayEffectCueEvents");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilitySystemComponent.FindAttributeInformation
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    AttributeName                                          (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAttributeInfo                   ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FAttributeInfo UFortAbilitySystemComponent::FindAttributeInformation(const class FString& AttributeName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilitySystemComponent", "FindAttributeInformation");

	Params::FortAbilitySystemComponent_FindAttributeInformation Parms{};

	Parms.AttributeName = std::move(AttributeName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilitySystemComponent.GetAttributeMagnitude
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FAttributeInfo&            Info                                                   (ConstParm, Parm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortAbilitySystemComponent::GetAttributeMagnitude(const struct FAttributeInfo& Info) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilitySystemComponent", "GetAttributeMagnitude");

	Params::FortAbilitySystemComponent_GetAttributeMagnitude Parms{};

	Parms.Info = std::move(Info);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilitySystemComponent.HasActiveAbilityWithAnyMatchingTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagContainer&     Tags                                                   (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAbilitySystemComponent::HasActiveAbilityWithAnyMatchingTag(const struct FGameplayTagContainer& Tags) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilitySystemComponent", "HasActiveAbilityWithAnyMatchingTag");

	Params::FortAbilitySystemComponent_HasActiveAbilityWithAnyMatchingTag Parms{};

	Parms.Tags = std::move(Tags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_CommitAccountCosts.CommitAccountCosts
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_CommitAccountCosts*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_CommitAccountCosts* UFortAbilityTask_CommitAccountCosts::CommitAccountCosts(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_CommitAccountCosts", "CommitAccountCosts");

	Params::FortAbilityTask_CommitAccountCosts_CommitAccountCosts Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerFrontEnd.SkipTutorial
// (Final, Exec, Native, Public)

void AFortPlayerControllerFrontEnd::SkipTutorial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerFrontEnd", "SkipTutorial");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerZone.ClientNotifyFogOfWarReplicationStart
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerControllerZone::ClientNotifyFogOfWarReplicationStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerZone", "ClientNotifyFogOfWarReplicationStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerZone.ClientOnPawnDied
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const struct FFortPlayerDeathReport&    DeathReport                                            (Parm, NativeAccessSpecifierPublic)

void AFortPlayerControllerZone::ClientOnPawnDied(const struct FFortPlayerDeathReport& DeathReport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerZone", "ClientOnPawnDied");

	Params::FortPlayerControllerZone_ClientOnPawnDied Parms{};

	Parms.DeathReport = std::move(DeathReport);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerZone.ClientReceiveFogOfWarBunch
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int32                                   Offset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   TotalSize                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<uint8>&                    BunchData                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerControllerZone::ClientReceiveFogOfWarBunch(int32 Offset, int32 TotalSize, const TArray<uint8>& BunchData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerZone", "ClientReceiveFogOfWarBunch");

	Params::FortPlayerControllerZone_ClientReceiveFogOfWarBunch Parms{};

	Parms.Offset = Offset;
	Parms.TotalSize = TotalSize;
	Parms.BunchData = std::move(BunchData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerZone.ServerRequestFogOfWarBunch
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int32                                   Offset                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerZone::ServerRequestFogOfWarBunch(int32 Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerZone", "ServerRequestFogOfWarBunch");

	Params::FortPlayerControllerZone_ServerRequestFogOfWarBunch Parms{};

	Parms.Offset = Offset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerPvP.ClientReceiveKillNotification
// (Net, Native, Event, Public, NetClient)
// Parameters:
// class AFortPlayerStateZone*             Killer                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerStateZone*             Killed                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerPvP::ClientReceiveKillNotification(class AFortPlayerStateZone* Killer, class AFortPlayerStateZone* Killed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerPvP", "ClientReceiveKillNotification");

	Params::FortPlayerControllerPvP_ClientReceiveKillNotification Parms{};

	Parms.Killer = Killer;
	Parms.Killed = Killed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerPvP.ClientShowGameOverWidget
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// EFortPvPGameResult                      GameResult                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerPvP::ClientShowGameOverWidget(EFortPvPGameResult GameResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerPvP", "ClientShowGameOverWidget");

	Params::FortPlayerControllerPvP_ClientShowGameOverWidget Parms{};

	Parms.GameResult = GameResult;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortFrontEndCameraManager.SetCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFrontEndCamera                         NewCamera                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortFrontEndCameraManager::SetCamera(EFrontEndCamera NewCamera)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndCameraManager", "SetCamera");

	Params::FortFrontEndCameraManager_SetCamera Parms{};

	Parms.NewCamera = NewCamera;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortFrontEndCameraManager.GetCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFrontEndCamera                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFrontEndCamera AFortFrontEndCameraManager::GetCamera() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndCameraManager", "GetCamera");

	Params::FortFrontEndCameraManager_GetCamera Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortFrontEndCameraManager.GetCameraActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortCameraBase*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortCameraBase* AFortFrontEndCameraManager::GetCameraActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortFrontEndCameraManager", "GetCameraActor");

	Params::FortFrontEndCameraManager_GetCameraActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_DirectedMovement.DirectedMovement
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MovementDirection                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EFortDirectedMovementSpace              MovementSpaceType                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementDistance_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementDuration                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   IdealDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ModifyZ                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelOnFalling_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortAbilityTask_DirectedMovement*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_DirectedMovement* UFortAbilityTask_DirectedMovement::DirectedMovement(class UObject* WorldContextObject, const struct FVector& MovementDirection, EFortDirectedMovementSpace MovementSpaceType, float MovementDistance_0, float MovementDuration, float IdealDistance, bool ModifyZ, bool bCancelOnFalling_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_DirectedMovement", "DirectedMovement");

	Params::FortAbilityTask_DirectedMovement_DirectedMovement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MovementDirection = std::move(MovementDirection);
	Parms.MovementSpaceType = MovementSpaceType;
	Parms.MovementDistance_0 = MovementDistance_0;
	Parms.MovementDuration = MovementDuration;
	Parms.IdealDistance = IdealDistance;
	Parms.ModifyZ = ModifyZ;
	Parms.bCancelOnFalling_0 = bCancelOnFalling_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_DirectedMovement.DirectedMovementToActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxMovementDistance                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementDuration                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   IdealDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ModifyZ                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelOnFalling_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortAbilityTask_DirectedMovement*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_DirectedMovement* UFortAbilityTask_DirectedMovement::DirectedMovementToActor(class UObject* WorldContextObject, class AActor* TargetActor, float MaxMovementDistance, float MovementDuration, float IdealDistance, bool ModifyZ, bool bCancelOnFalling_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_DirectedMovement", "DirectedMovementToActor");

	Params::FortAbilityTask_DirectedMovement_DirectedMovementToActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetActor = TargetActor;
	Parms.MaxMovementDistance = MaxMovementDistance;
	Parms.MovementDuration = MovementDuration;
	Parms.IdealDistance = IdealDistance;
	Parms.ModifyZ = ModifyZ;
	Parms.bCancelOnFalling_0 = bCancelOnFalling_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_DirectedMovement.DirectedMovementToComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  TargetComponent_0                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxMovementDistance                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementDuration                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   IdealDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ModifyZ                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelOnFalling_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortAbilityTask_DirectedMovement*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_DirectedMovement* UFortAbilityTask_DirectedMovement::DirectedMovementToComponent(class UObject* WorldContextObject, class USceneComponent* TargetComponent_0, float MaxMovementDistance, float MovementDuration, float IdealDistance, bool ModifyZ, bool bCancelOnFalling_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_DirectedMovement", "DirectedMovementToComponent");

	Params::FortAbilityTask_DirectedMovement_DirectedMovementToComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetComponent_0 = TargetComponent_0;
	Parms.MaxMovementDistance = MaxMovementDistance;
	Parms.MovementDuration = MovementDuration;
	Parms.IdealDistance = IdealDistance;
	Parms.ModifyZ = ModifyZ;
	Parms.bCancelOnFalling_0 = bCancelOnFalling_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_DirectedMovement.DirectedMovementToLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MovementTargetLocation                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EFortDirectedMovementSpace              MovementSpaceType                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MovementDuration                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CloseEnoughDistance                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ModifyZ                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelOnFalling_0                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortAbilityTask_DirectedMovement*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_DirectedMovement* UFortAbilityTask_DirectedMovement::DirectedMovementToLocation(class UObject* WorldContextObject, const struct FVector& MovementTargetLocation, EFortDirectedMovementSpace MovementSpaceType, float MovementDuration, float CloseEnoughDistance, bool ModifyZ, bool bCancelOnFalling_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_DirectedMovement", "DirectedMovementToLocation");

	Params::FortAbilityTask_DirectedMovement_DirectedMovementToLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MovementTargetLocation = std::move(MovementTargetLocation);
	Parms.MovementSpaceType = MovementSpaceType;
	Parms.MovementDuration = MovementDuration;
	Parms.CloseEnoughDistance = CloseEnoughDistance;
	Parms.ModifyZ = ModifyZ;
	Parms.bCancelOnFalling_0 = bCancelOnFalling_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_MoveAI.CreateMoveAITask
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           MoveActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MoveLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EPawnActionMoveMode                     MoveMode                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPathObstacleAction                     PathObstacleAction                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopAtEnd                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    bFinishOnPlayerCollision                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// float                                   AcceptableRadius                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortPawn>            PushBumpedPawnClass                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_MoveAI*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_MoveAI* UFortAbilityTask_MoveAI::CreateMoveAITask(class UObject* WorldContextObject, class FName TaskInstanceName, class AActor* MoveActor, const struct FVector& MoveLocation, EPawnActionMoveMode MoveMode, EPathObstacleAction PathObstacleAction, bool bStopAtEnd, bool bFinishOnPlayerCollision, float AcceptableRadius, TSubclassOf<class AFortPawn> PushBumpedPawnClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_MoveAI", "CreateMoveAITask");

	Params::FortAbilityTask_MoveAI_CreateMoveAITask Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.MoveActor = MoveActor;
	Parms.MoveLocation = std::move(MoveLocation);
	Parms.MoveMode = MoveMode;
	Parms.PathObstacleAction = PathObstacleAction;
	Parms.bStopAtEnd = bStopAtEnd;
	Parms.bFinishOnPlayerCollision = bFinishOnPlayerCollision;
	Parms.AcceptableRadius = AcceptableRadius;
	Parms.PushBumpedPawnClass = PushBumpedPawnClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerManor.ClientOpenManorPortalUnlockMenu
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// class AManorPortal*                     ManorPortal                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerManor::ClientOpenManorPortalUnlockMenu(class AManorPortal* ManorPortal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerManor", "ClientOpenManorPortalUnlockMenu");

	Params::FortPlayerControllerManor_ClientOpenManorPortalUnlockMenu Parms{};

	Parms.ManorPortal = ManorPortal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerManor.ServerOnManorChoiceCompleted
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int32                                   ChosenItem                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerManor::ServerOnManorChoiceCompleted(int32 ChosenItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerManor", "ServerOnManorChoiceCompleted");

	Params::FortPlayerControllerManor_ServerOnManorChoiceCompleted Parms{};

	Parms.ChosenItem = ChosenItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerManor.ServerOnUnlockPortalComplete
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class AManorPortal*                     ManorPortal                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerManor::ServerOnUnlockPortalComplete(class AManorPortal* ManorPortal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerManor", "ServerOnUnlockPortalComplete");

	Params::FortPlayerControllerManor_ServerOnUnlockPortalComplete Parms{};

	Parms.ManorPortal = ManorPortal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_WaitTargetSelection.WaitTargetSelection
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              InApplicationTag                                       (Parm, NativeAccessSpecifierPublic)
// bool                                    bForceTargetingOnServer_0                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortAbilityTask_WaitTargetSelection*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_WaitTargetSelection* UFortAbilityTask_WaitTargetSelection::WaitTargetSelection(class UObject* WorldContextObject, class FName TaskInstanceName, const struct FGameplayTag& InApplicationTag, bool bForceTargetingOnServer_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_WaitTargetSelection", "WaitTargetSelection");

	Params::FortAbilityTask_WaitTargetSelection_WaitTargetSelection Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.InApplicationTag = std::move(InApplicationTag);
	Parms.bForceTargetingOnServer_0 = bForceTargetingOnServer_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_WaitTargetSelection.OnTargetDataCancelledCallback
// (Final, Native, Public)

void UFortAbilityTask_WaitTargetSelection::OnTargetDataCancelledCallback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_WaitTargetSelection", "OnTargetDataCancelledCallback");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_WaitTargetSelection.OnTargetDataReadyCallback
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAbilityTargetDataHandle&TargetData                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ApplicationTag                                         (Parm, NativeAccessSpecifierPublic)

void UFortAbilityTask_WaitTargetSelection::OnTargetDataReadyCallback(const struct FGameplayAbilityTargetDataHandle& TargetData, const struct FGameplayTag& ApplicationTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_WaitTargetSelection", "OnTargetDataReadyCallback");

	Params::FortAbilityTask_WaitTargetSelection_OnTargetDataReadyCallback Parms{};

	Parms.TargetData = std::move(TargetData);
	Parms.ApplicationTag = std::move(ApplicationTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityTask_SetNextMontageSectionAndWait.SetNextMontageSectionAndWait
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     PlayingMontage                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             NextMontageSection                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAbilityTask_SetNextMontageSectionAndWait*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAbilityTask_SetNextMontageSectionAndWait* UFortAbilityTask_SetNextMontageSectionAndWait::SetNextMontageSectionAndWait(class UObject* WorldContextObject, class UAnimMontage* PlayingMontage, class FName NextMontageSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAbilityTask_SetNextMontageSectionAndWait", "SetNextMontageSectionAndWait");

	Params::FortAbilityTask_SetNextMontageSectionAndWait_SetNextMontageSectionAndWait Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayingMontage = PlayingMontage;
	Parms.NextMontageSection = NextMontageSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityTask_SetNextMontageSectionAndWait.OnMontageBlendingOut
// (Final, Native, Public)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortAbilityTask_SetNextMontageSectionAndWait::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityTask_SetNextMontageSectionAndWait", "OnMontageBlendingOut");

	Params::FortAbilityTask_SetNextMontageSectionAndWait_OnMontageBlendingOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.CreateDynamicBuildingDeconstructor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Origin                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxExtent                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIgnoreMissionActors                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bShrinkAndDestroy                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::CreateDynamicBuildingDeconstructor(class UObject* WorldContextObject, const struct FVector& Origin, const struct FVector& BoxExtent, bool bIgnoreMissionActors, bool bShrinkAndDestroy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "CreateDynamicBuildingDeconstructor");

	Params::FortMissionLibrary_CreateDynamicBuildingDeconstructor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Origin = std::move(Origin);
	Parms.BoxExtent = std::move(BoxExtent);
	Parms.bIgnoreMissionActors = bIgnoreMissionActors;
	Parms.bShrinkAndDestroy = bShrinkAndDestroy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.CreateMissionEvent
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// class UFortMissionEventParams*          Params_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    DO_NOT_USE_THIS_OR_VARIABLES_BELOW                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataAsset*                       EventContent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GenericInt                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GenericFloat                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      GenericText                                            (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, NativeAccessSpecifierPublic)
// struct FFortMissionEvent                ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortMissionEvent UFortMissionLibrary::CreateMissionEvent(class UObject* WorldContextObject, class FName EventType, const struct FGuid& MissionGuid, const struct FGameplayTagContainer& ObjectiveHandle, class UFortMissionEventParams* Params_0, bool DO_NOT_USE_THIS_OR_VARIABLES_BELOW, class UObject* EventFocus, class UDataAsset* EventContent, class AActor* EventInstigator, int32 GenericInt, float GenericFloat, const class FText& GenericText, const struct FGameplayTagContainer& GameplayTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "CreateMissionEvent");

	Params::FortMissionLibrary_CreateMissionEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventType = EventType;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.ObjectiveHandle = std::move(ObjectiveHandle);
	Parms.Params_0 = Params_0;
	Parms.DO_NOT_USE_THIS_OR_VARIABLES_BELOW = DO_NOT_USE_THIS_OR_VARIABLES_BELOW;
	Parms.EventFocus = EventFocus;
	Parms.EventContent = EventContent;
	Parms.EventInstigator = EventInstigator;
	Parms.GenericInt = GenericInt;
	Parms.GenericFloat = GenericFloat;
	Parms.GenericText = std::move(GenericText);
	Parms.GameplayTags = std::move(GameplayTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.ExecuteMissionEvent
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// class UFortMissionEventParams*          Params_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    DO_NOT_USE_THIS_OR_VARIABLES_BELOW                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataAsset*                       EventContent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GenericInt                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GenericFloat                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      GenericText                                            (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, NativeAccessSpecifierPublic)

void UFortMissionLibrary::ExecuteMissionEvent(class UObject* WorldContextObject, class FName EventType, const struct FGuid& MissionGuid, const struct FGameplayTagContainer& ObjectiveHandle, class UFortMissionEventParams* Params_0, bool DO_NOT_USE_THIS_OR_VARIABLES_BELOW, class UObject* EventFocus, class UDataAsset* EventContent, class AActor* EventInstigator, int32 GenericInt, float GenericFloat, const class FText& GenericText, const struct FGameplayTagContainer& GameplayTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "ExecuteMissionEvent");

	Params::FortMissionLibrary_ExecuteMissionEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventType = EventType;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.ObjectiveHandle = std::move(ObjectiveHandle);
	Parms.Params_0 = Params_0;
	Parms.DO_NOT_USE_THIS_OR_VARIABLES_BELOW = DO_NOT_USE_THIS_OR_VARIABLES_BELOW;
	Parms.EventFocus = EventFocus;
	Parms.EventContent = EventContent;
	Parms.EventInstigator = EventInstigator;
	Parms.GenericInt = GenericInt;
	Parms.GenericFloat = GenericFloat;
	Parms.GenericText = std::move(GenericText);
	Parms.GameplayTags = std::move(GameplayTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.ExecuteMissionEventEx
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortMissionEventName&     EventType                                              (Parm, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// class UFortMissionEventParams*          Params_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    DO_NOT_USE_THIS_OR_VARIABLES_BELOW                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataAsset*                       EventContent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GenericInt                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GenericFloat                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      GenericText                                            (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, NativeAccessSpecifierPublic)

void UFortMissionLibrary::ExecuteMissionEventEx(class UObject* WorldContextObject, const struct FFortMissionEventName& EventType, const struct FGuid& MissionGuid, const struct FGameplayTagContainer& ObjectiveHandle, class UFortMissionEventParams* Params_0, bool DO_NOT_USE_THIS_OR_VARIABLES_BELOW, class UObject* EventFocus, class UDataAsset* EventContent, class AActor* EventInstigator, int32 GenericInt, float GenericFloat, const class FText& GenericText, const struct FGameplayTagContainer& GameplayTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "ExecuteMissionEventEx");

	Params::FortMissionLibrary_ExecuteMissionEventEx Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventType = std::move(EventType);
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.ObjectiveHandle = std::move(ObjectiveHandle);
	Parms.Params_0 = Params_0;
	Parms.DO_NOT_USE_THIS_OR_VARIABLES_BELOW = DO_NOT_USE_THIS_OR_VARIABLES_BELOW;
	Parms.EventFocus = EventFocus;
	Parms.EventContent = EventContent;
	Parms.EventInstigator = EventInstigator;
	Parms.GenericInt = GenericInt;
	Parms.GenericFloat = GenericFloat;
	Parms.GenericText = std::move(GenericText);
	Parms.GameplayTags = std::move(GameplayTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.FindActorsWithTags
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     Tags                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class ABuildingActor*>           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ABuildingActor*> UFortMissionLibrary::FindActorsWithTags(class UObject* WorldContextObject, const struct FGameplayTagContainer& Tags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "FindActorsWithTags");

	Params::FortMissionLibrary_FindActorsWithTags Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Tags = std::move(Tags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.FindOriginatingPlacementActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ABuildingActor*                   BuildingActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlacementActor*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlacementActor* UFortMissionLibrary::FindOriginatingPlacementActor(class ABuildingActor* BuildingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "FindOriginatingPlacementActor");

	Params::FortMissionLibrary_FindOriginatingPlacementActor Parms{};

	Parms.BuildingActor = BuildingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.GetAllLoadedMissions
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AFortMission*>             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AFortMission*> UFortMissionLibrary::GetAllLoadedMissions(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GetAllLoadedMissions");

	Params::FortMissionLibrary_GetAllLoadedMissions Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.GetBluGloManager
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortBluGloManager*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortBluGloManager* UFortMissionLibrary::GetBluGloManager(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GetBluGloManager");

	Params::FortMissionLibrary_GetBluGloManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.GetMissionFromGuid
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortMission*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortMission* UFortMissionLibrary::GetMissionFromGuid(class UObject* WorldContextObject, const struct FGuid& MissionGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GetMissionFromGuid");

	Params::FortMissionLibrary_GetMissionFromGuid Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.GiveMissionRewardsToPlayer
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     EventGuid                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      TitleText                                              (Parm, NativeAccessSpecifierPublic)
// const class FText&                      DescriptionText                                        (Parm, NativeAccessSpecifierPublic)
// class FName                             LootTierGroup                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LootTier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RewardDisplayTime                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::GiveMissionRewardsToPlayer(class UObject* WorldContextObject, const struct FGuid& EventGuid, class AFortPlayerController* PlayerController, const class FText& TitleText, const class FText& DescriptionText, class FName LootTierGroup, int32 LootTier, float RewardDisplayTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GiveMissionRewardsToPlayer");

	Params::FortMissionLibrary_GiveMissionRewardsToPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventGuid = std::move(EventGuid);
	Parms.PlayerController = PlayerController;
	Parms.TitleText = std::move(TitleText);
	Parms.DescriptionText = std::move(DescriptionText);
	Parms.LootTierGroup = LootTierGroup;
	Parms.LootTier = LootTier;
	Parms.RewardDisplayTime = RewardDisplayTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.GiveMissionRewardsToPlayerAsPickups
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartPosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             LootTierGroup                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   LootTier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::GiveMissionRewardsToPlayerAsPickups(class UObject* WorldContextObject, const struct FGuid& MissionGuid, class AFortPlayerController* PlayerController, const struct FVector& StartPosition, float Radius, class FName LootTierGroup, int32 LootTier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GiveMissionRewardsToPlayerAsPickups");

	Params::FortMissionLibrary_GiveMissionRewardsToPlayerAsPickups Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.PlayerController = PlayerController;
	Parms.StartPosition = std::move(StartPosition);
	Parms.Radius = Radius;
	Parms.LootTierGroup = LootTierGroup;
	Parms.LootTier = LootTier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.GiveMissionSchematicItemDirectlyToPlayer
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            TargetPlayer                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortSchematicItemDefinition*     SchematicDefinition                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::GiveMissionSchematicItemDirectlyToPlayer(class UObject* WorldContextObject, class AFortPlayerController* TargetPlayer, const struct FGuid& MissionGuid, class UFortSchematicItemDefinition* SchematicDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "GiveMissionSchematicItemDirectlyToPlayer");

	Params::FortMissionLibrary_GiveMissionSchematicItemDirectlyToPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetPlayer = TargetPlayer;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.SchematicDefinition = SchematicDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.HasTags
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     ContainerToCheck                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     TagsToCheck                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bRequireAll                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCountEmptyAsMatch                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::HasTags(const struct FGameplayTagContainer& ContainerToCheck, const struct FGameplayTagContainer& TagsToCheck, bool bRequireAll, bool bCountEmptyAsMatch)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "HasTags");

	Params::FortMissionLibrary_HasTags Parms{};

	Parms.ContainerToCheck = std::move(ContainerToCheck);
	Parms.TagsToCheck = std::move(TagsToCheck);
	Parms.bRequireAll = bRequireAll;
	Parms.bCountEmptyAsMatch = bCountEmptyAsMatch;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.IsUsingNewMissionGeneration
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::IsUsingNewMissionGeneration(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "IsUsingNewMissionGeneration");

	Params::FortMissionLibrary_IsUsingNewMissionGeneration Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.LoadMission
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortMissionInfo*                 MissionInfo                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::LoadMission(class UObject* WorldContextObject, class UFortMissionInfo* MissionInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "LoadMission");

	Params::FortMissionLibrary_LoadMission Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionInfo = MissionInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.NumBluGloFromPlayerPawn
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortMissionLibrary::NumBluGloFromPlayerPawn(class AFortPlayerPawn* PlayerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "NumBluGloFromPlayerPawn");

	Params::FortMissionLibrary_NumBluGloFromPlayerPawn Parms{};

	Parms.PlayerPawn = PlayerPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.NumBluGloFromPlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerStateZone*             PlayerState                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortMissionLibrary::NumBluGloFromPlayerState(class AFortPlayerStateZone* PlayerState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "NumBluGloFromPlayerState");

	Params::FortMissionLibrary_NumBluGloFromPlayerState Parms{};

	Parms.PlayerState = PlayerState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.PingMinimap
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              PingColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::PingMinimap(class UObject* WorldContextObject, const struct FVector& WorldLocation, const struct FLinearColor& PingColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "PingMinimap");

	Params::FortMissionLibrary_PingMinimap Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.WorldLocation = std::move(WorldLocation);
	Parms.PingColor = std::move(PingColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.PollActorsInVolume
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBoxComponent*                    VolumeBoxComponent                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPollActorsInVolumeTypes                PollBuildingTypes                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class AActor>               ActorClassToPoll                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortMissionLibrary::PollActorsInVolume(class UObject* WorldContextObject, class UBoxComponent* VolumeBoxComponent, EPollActorsInVolumeTypes PollBuildingTypes, TSubclassOf<class AActor> ActorClassToPoll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "PollActorsInVolume");

	Params::FortMissionLibrary_PollActorsInVolume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.VolumeBoxComponent = VolumeBoxComponent;
	Parms.PollBuildingTypes = PollBuildingTypes;
	Parms.ActorClassToPoll = ActorClassToPoll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.RegisterForMissionEvents
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           ActorToRegister                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::RegisterForMissionEvents(class AActor* ActorToRegister, const struct FGuid& MissionGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "RegisterForMissionEvents");

	Params::FortMissionLibrary_RegisterForMissionEvents Parms{};

	Parms.ActorToRegister = ActorToRegister;
	Parms.MissionGuid = std::move(MissionGuid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.RegisterMissionInfoUIActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           AttachmentActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   AttachementOffset                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   MaxVisibleDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::RegisterMissionInfoUIActor(class AActor* AttachmentActor, const struct FGuid& MissionGuid, const struct FVector& AttachementOffset, float MaxVisibleDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "RegisterMissionInfoUIActor");

	Params::FortMissionLibrary_RegisterMissionInfoUIActor Parms{};

	Parms.AttachmentActor = AttachmentActor;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.AttachementOffset = std::move(AttachementOffset);
	Parms.MaxVisibleDistance = MaxVisibleDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.SetOnlinePresenceDoNotDisturb
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDoNotDisturb                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpecificPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::SetOnlinePresenceDoNotDisturb(class UObject* WorldContextObject, bool bDoNotDisturb, class AFortPlayerController* SpecificPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "SetOnlinePresenceDoNotDisturb");

	Params::FortMissionLibrary_SetOnlinePresenceDoNotDisturb Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bDoNotDisturb = bDoNotDisturb;
	Parms.SpecificPlayer = SpecificPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.ShouldUseAlternateAIDirectorBalance
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::ShouldUseAlternateAIDirectorBalance()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "ShouldUseAlternateAIDirectorBalance");

	Params::FortMissionLibrary_ShouldUseAlternateAIDirectorBalance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.SpawnAtPlacementActorsHelper
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           Entries                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bSucceeded                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UFortMissionLibrary::SpawnAtPlacementActorsHelper(class UObject* WorldContextObject, class UClass* Entries, bool* bSucceeded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "SpawnAtPlacementActorsHelper");

	Params::FortMissionLibrary_SpawnAtPlacementActorsHelper Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Entries = Entries;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bSucceeded != nullptr)
		*bSucceeded = Parms.bSucceeded;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.SpawnBuildingActorAtTransform
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// TSubclassOf<class ABuildingActor>       BuildingClass                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class ABuildingActor*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingActor* UFortMissionLibrary::SpawnBuildingActorAtTransform(class UObject* WorldContextObject, const struct FGuid& MissionGuid, TSubclassOf<class ABuildingActor> BuildingClass, const struct FTransform& Transform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "SpawnBuildingActorAtTransform");

	Params::FortMissionLibrary_SpawnBuildingActorAtTransform Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.BuildingClass = BuildingClass;
	Parms.Transform = std::move(Transform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.SpawnMissionItemPickup
// (Final, Native, Static, Public, HasDefaults)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortMissionItemDefinition*       MissionItemDefinition                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartPosition                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPawn*                        TargetPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPickup* UFortMissionLibrary::SpawnMissionItemPickup(class UObject* WorldContextObject, const struct FGuid& MissionGuid, class UFortMissionItemDefinition* MissionItemDefinition, const struct FVector& StartPosition, class AFortPawn* TargetPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "SpawnMissionItemPickup");

	Params::FortMissionLibrary_SpawnMissionItemPickup Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.MissionItemDefinition = MissionItemDefinition;
	Parms.StartPosition = std::move(StartPosition);
	Parms.TargetPawn = TargetPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.SpawnMissionItemPickupInWorld
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberToSpawn                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   OverrideMaxStackCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPickup*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPickup* UFortMissionLibrary::SpawnMissionItemPickupInWorld(class UObject* WorldContextObject, const struct FGuid& MissionGuid, class UFortWorldItemDefinition* ItemDefinition, int32 NumberToSpawn, const struct FVector& Position, const struct FVector& Direction, int32 OverrideMaxStackCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "SpawnMissionItemPickupInWorld");

	Params::FortMissionLibrary_SpawnMissionItemPickupInWorld Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.ItemDefinition = ItemDefinition;
	Parms.NumberToSpawn = NumberToSpawn;
	Parms.Position = std::move(Position);
	Parms.Direction = std::move(Direction);
	Parms.OverrideMaxStackCount = OverrideMaxStackCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.StartAIEncounter
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          AssociatedMissionName                                  (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InjectedTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortEncounterSettings&    EncounterSettings                                      (Parm, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* UFortMissionLibrary::StartAIEncounter(class UObject* WorldContextObject, class FString* AssociatedMissionName, TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate, class AActor* TargetActor, const struct FGameplayTagContainer& InjectedTags, const struct FFortEncounterSettings& EncounterSettings, int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StartAIEncounter");

	Params::FortMissionLibrary_StartAIEncounter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EncounterTemplate = EncounterTemplate;
	Parms.TargetActor = TargetActor;
	Parms.InjectedTags = std::move(InjectedTags);
	Parms.EncounterSettings = std::move(EncounterSettings);
	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AssociatedMissionName != nullptr)
		*AssociatedMissionName = std::move(Parms.AssociatedMissionName);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.StartAIEncounterWithEnvironmentQuery
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          AssociatedMissionName                                  (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEncounterEnvironmentQueryInfo&EnvironmentQueryInfo                                   (Parm, NativeAccessSpecifierPublic)
// class AActor*                           QueryActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InjectedTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortEncounterSettings&    EncounterSettings                                      (Parm, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* UFortMissionLibrary::StartAIEncounterWithEnvironmentQuery(class UObject* WorldContextObject, class FString* AssociatedMissionName, TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate, class AActor* TargetActor, const struct FEncounterEnvironmentQueryInfo& EnvironmentQueryInfo, class AActor* QueryActor, const struct FGameplayTagContainer& InjectedTags, const struct FFortEncounterSettings& EncounterSettings, int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StartAIEncounterWithEnvironmentQuery");

	Params::FortMissionLibrary_StartAIEncounterWithEnvironmentQuery Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EncounterTemplate = EncounterTemplate;
	Parms.TargetActor = TargetActor;
	Parms.EnvironmentQueryInfo = std::move(EnvironmentQueryInfo);
	Parms.QueryActor = QueryActor;
	Parms.InjectedTags = std::move(InjectedTags);
	Parms.EncounterSettings = std::move(EncounterSettings);
	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AssociatedMissionName != nullptr)
		*AssociatedMissionName = std::move(Parms.AssociatedMissionName);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionLibrary.StartNotification
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortClientNotification>Notification                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpecificPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      OverrideTitleText                                      (Parm, AdvancedDisplay, NativeAccessSpecifierPublic)
// const class FText&                      OverrideDisplayText                                    (Parm, NativeAccessSpecifierPublic)
// float                                   OverrideDisplayTime                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn1                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn2                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             OptionalActionName                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USoundBase*                 OptionalSound                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bPlaySoundAsFeedback                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bTreatAsUnique                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelActiveNotification                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    bWaitForClients                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::StartNotification(class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo, TSubclassOf<class AFortClientNotification> Notification, class AFortPlayerController* SpecificPlayer, const class FText& OverrideTitleText, const class FText& OverrideDisplayText, float OverrideDisplayTime, class AFortPlayerPawn* OptionalPlayerPawn1, class AFortPlayerPawn* OptionalPlayerPawn2, class FName OptionalActionName, const class USoundBase* OptionalSound, bool bPlaySoundAsFeedback, bool bTreatAsUnique, bool bCancelActiveNotification, bool bWaitForClients)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StartNotification");

	Params::FortMissionLibrary_StartNotification Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Notification = Notification;
	Parms.SpecificPlayer = SpecificPlayer;
	Parms.OverrideTitleText = std::move(OverrideTitleText);
	Parms.OverrideDisplayText = std::move(OverrideDisplayText);
	Parms.OverrideDisplayTime = OverrideDisplayTime;
	Parms.OptionalPlayerPawn1 = OptionalPlayerPawn1;
	Parms.OptionalPlayerPawn2 = OptionalPlayerPawn2;
	Parms.OptionalActionName = OptionalActionName;
	Parms.OptionalSound = OptionalSound;
	Parms.bPlaySoundAsFeedback = bPlaySoundAsFeedback;
	Parms.bTreatAsUnique = bTreatAsUnique;
	Parms.bCancelActiveNotification = bCancelActiveNotification;
	Parms.bWaitForClients = bWaitForClients;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.StartPlayingMission
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UFortMissionEventParams*          Params_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UDataAsset*                       EventContent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GenericInt                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GenericFloat                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      GenericText                                            (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, NativeAccessSpecifierPublic)

void UFortMissionLibrary::StartPlayingMission(class UObject* WorldContextObject, const struct FGuid& MissionGuid, class UFortMissionEventParams* Params_0, class UObject* EventFocus, class UDataAsset* EventContent, class AActor* EventInstigator, int32 GenericInt, float GenericFloat, const class FText& GenericText, const struct FGameplayTagContainer& GameplayTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StartPlayingMission");

	Params::FortMissionLibrary_StartPlayingMission Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MissionGuid = std::move(MissionGuid);
	Parms.Params_0 = Params_0;
	Parms.EventFocus = EventFocus;
	Parms.EventContent = EventContent;
	Parms.EventInstigator = EventInstigator;
	Parms.GenericInt = GenericInt;
	Parms.GenericFloat = GenericFloat;
	Parms.GenericText = std::move(GenericText);
	Parms.GameplayTags = std::move(GameplayTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.StartTutorialNotification
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortClientNotification>Notification                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpecificPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn1                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn2                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      OverrideTitleText                                      (Parm, NativeAccessSpecifierPublic)
// const class FText&                      OverrideDisplayText                                    (Parm, NativeAccessSpecifierPublic)
// const class FText&                      OverrideSystemText                                     (Parm, NativeAccessSpecifierPublic)
// const class FText&                      OverrideNameText                                       (Parm, NativeAccessSpecifierPublic)
// float                                   OverrideDisplayTime                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bOverrideButtonEnabled                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bOverrideLightboxEnabled                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bOverrideLightboxDisableInputOnly                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// EVerticalAlignment                      OverrideVAlign                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EHorizontalAlignment                    OverrideHAlign                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FMargin&                   OverridePadding                                        (Parm, NativeAccessSpecifierPublic)
// const class USoundBase*                 OptionalSound                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWaitForClients                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::StartTutorialNotification(class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo, TSubclassOf<class AFortClientNotification> Notification, class AFortPlayerController* SpecificPlayer, class AFortPlayerPawn* OptionalPlayerPawn1, class AFortPlayerPawn* OptionalPlayerPawn2, const class FText& OverrideTitleText, const class FText& OverrideDisplayText, const class FText& OverrideSystemText, const class FText& OverrideNameText, float OverrideDisplayTime, bool bOverrideButtonEnabled, bool bOverrideLightboxEnabled, bool bOverrideLightboxDisableInputOnly, EVerticalAlignment OverrideVAlign, EHorizontalAlignment OverrideHAlign, const struct FMargin& OverridePadding, const class USoundBase* OptionalSound, bool bWaitForClients)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StartTutorialNotification");

	Params::FortMissionLibrary_StartTutorialNotification Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Notification = Notification;
	Parms.SpecificPlayer = SpecificPlayer;
	Parms.OptionalPlayerPawn1 = OptionalPlayerPawn1;
	Parms.OptionalPlayerPawn2 = OptionalPlayerPawn2;
	Parms.OverrideTitleText = std::move(OverrideTitleText);
	Parms.OverrideDisplayText = std::move(OverrideDisplayText);
	Parms.OverrideSystemText = std::move(OverrideSystemText);
	Parms.OverrideNameText = std::move(OverrideNameText);
	Parms.OverrideDisplayTime = OverrideDisplayTime;
	Parms.bOverrideButtonEnabled = bOverrideButtonEnabled;
	Parms.bOverrideLightboxEnabled = bOverrideLightboxEnabled;
	Parms.bOverrideLightboxDisableInputOnly = bOverrideLightboxDisableInputOnly;
	Parms.OverrideVAlign = OverrideVAlign;
	Parms.OverrideHAlign = OverrideHAlign;
	Parms.OverridePadding = std::move(OverridePadding);
	Parms.OptionalSound = OptionalSound;
	Parms.bWaitForClients = bWaitForClients;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.StopAIEncounter
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ActiveEncounter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::StopAIEncounter(class UObject* WorldContextObject, class UFortAIEncounterInfo* ActiveEncounter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StopAIEncounter");

	Params::FortMissionLibrary_StopAIEncounter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActiveEncounter = ActiveEncounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.StopAIEncounterAgainstActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionLibrary::StopAIEncounterAgainstActor(class UObject* WorldContextObject, class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "StopAIEncounterAgainstActor");

	Params::FortMissionLibrary_StopAIEncounterAgainstActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetActor = TargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.TeleportPawnNearLocation
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AFortPawn*                        Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DestLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::TeleportPawnNearLocation(class AFortPawn* Pawn, const struct FVector& DestLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "TeleportPawnNearLocation");

	Params::FortMissionLibrary_TeleportPawnNearLocation Parms{};

	Parms.Pawn = Pawn;
	Parms.DestLocation = std::move(DestLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.TeleportPlayerPawn
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DestLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  DestRotation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionLibrary::TeleportPlayerPawn(class AFortPlayerPawn* PlayerPawn, const struct FVector& DestLocation, const struct FRotator& DestRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "TeleportPlayerPawn");

	Params::FortMissionLibrary_TeleportPlayerPawn Parms{};

	Parms.PlayerPawn = PlayerPawn;
	Parms.DestLocation = std::move(DestLocation);
	Parms.DestRotation = std::move(DestRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionLibrary.UnregisterForMissionEvents
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           ActorToUnregister                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     MissionGuid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionLibrary::UnregisterForMissionEvents(class AActor* ActorToUnregister, const struct FGuid& MissionGuid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMissionLibrary", "UnregisterForMissionEvents");

	Params::FortMissionLibrary_UnregisterForMissionEvents Parms{};

	Parms.ActorToUnregister = ActorToUnregister;
	Parms.MissionGuid = std::move(MissionGuid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.IsIgnoringProximity
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIController*                FortAIController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIController::IsIgnoringProximity(class AFortAIController* FortAIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIController", "IsIgnoringProximity");

	Params::FortAIController_IsIgnoringProximity Parms{};

	Parms.FortAIController = FortAIController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.CreateBuildingActor
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class ABuildingSMActor>     BuildingClass                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BuildLoc                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  BuildRot                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bMirrored                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIController::CreateBuildingActor(TSubclassOf<class ABuildingSMActor> BuildingClass, const struct FVector& BuildLoc, const struct FRotator& BuildRot, bool bMirrored)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "CreateBuildingActor");

	Params::FortAIController_CreateBuildingActor Parms{};

	Parms.BuildingClass = BuildingClass;
	Parms.BuildLoc = std::move(BuildLoc);
	Parms.BuildRot = std::move(BuildRot);
	Parms.bMirrored = bMirrored;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.GetBestKnownActorLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           ActorInQuestion                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  LastStimulusAge                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortAIController::GetBestKnownActorLocation(class AActor* ActorInQuestion, float* LastStimulusAge)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "GetBestKnownActorLocation");

	Params::FortAIController_GetBestKnownActorLocation Parms{};

	Parms.ActorInQuestion = ActorInQuestion;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (LastStimulusAge != nullptr)
		*LastStimulusAge = Parms.LastStimulusAge;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.GetClosestSupportingBuildingActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABuildingSMActor*                 BuildingSMActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuildingSMActor*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingSMActor* AFortAIController::GetClosestSupportingBuildingActor(class ABuildingSMActor* BuildingSMActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "GetClosestSupportingBuildingActor");

	Params::FortAIController_GetClosestSupportingBuildingActor Parms{};

	Parms.BuildingSMActor = BuildingSMActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.GetTargetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortAIController::GetTargetActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "GetTargetActor");

	Params::FortAIController_GetTargetActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.IgnoreProximityForDuration
// (Native, Public, BlueprintCallable)
// Parameters:
// float                                   DurationToIgnore                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIController::IgnoreProximityForDuration(float DurationToIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "IgnoreProximityForDuration");

	Params::FortAIController_IgnoreProximityForDuration Parms{};

	Parms.DurationToIgnore = DurationToIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.IsAllowedToSleep
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortAIController::IsAllowedToSleep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "IsAllowedToSleep");

	Params::FortAIController_IsAllowedToSleep Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIController.LockBehaviorResource
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::LockBehaviorResource()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "LockBehaviorResource");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.LockMovementResource
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::LockMovementResource()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "LockMovementResource");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.OnBuildingActorGoalDestroyed
// (Final, Native, Public)

void AFortAIController::OnBuildingActorGoalDestroyed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "OnBuildingActorGoalDestroyed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SendAnimNotification
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIController::SendAnimNotification(const class FString& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SendAnimNotification");

	Params::FortAIController_SendAnimNotification Parms{};

	Parms.EventName = std::move(EventName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetAlwaysGameplayRelevant
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInAlwaysGameplayRelevant                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIController::SetAlwaysGameplayRelevant(bool bInAlwaysGameplayRelevant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetAlwaysGameplayRelevant");

	Params::FortAIController_SetAlwaysGameplayRelevant Parms{};

	Parms.bInAlwaysGameplayRelevant = bInAlwaysGameplayRelevant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetGoalActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLocationAlwaysKnown                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIController::SetGoalActor(class AActor* InActor, bool bLocationAlwaysKnown)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetGoalActor");

	Params::FortAIController_SetGoalActor Parms{};

	Parms.InActor = InActor;
	Parms.bLocationAlwaysKnown = bLocationAlwaysKnown;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetIsSleeping
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewSleepStatus                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortAIController::SetIsSleeping(bool bNewSleepStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetIsSleeping");

	Params::FortAIController_SetIsSleeping Parms{};

	Parms.bNewSleepStatus = bNewSleepStatus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetPawnAIType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortressAIType                         NewAIType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           SpawnSpot                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIController::SetPawnAIType(EFortressAIType NewAIType, class AActor* SpawnSpot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetPawnAIType");

	Params::FortAIController_SetPawnAIType Parms{};

	Parms.NewAIType = NewAIType;
	Parms.SpawnSpot = SpawnSpot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetTeam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIController::SetTeam(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetTeam");

	Params::FortAIController_SetTeam Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.SetupCustomVIM
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                           VIM                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortAIController::SetupCustomVIM(class UClass* VIM)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "SetupCustomVIM");

	Params::FortAIController_SetupCustomVIM Parms{};

	Parms.VIM = VIM;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.UnlockBehaviorResource
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::UnlockBehaviorResource()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "UnlockBehaviorResource");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.UnlockMovementResource
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::UnlockMovementResource()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "UnlockMovementResource");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.UnregisterForGoalDetection
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::UnregisterForGoalDetection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "UnregisterForGoalDetection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.WakeUp
// (Final, Native, Public, BlueprintCallable)

void AFortAIController::WakeUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "WakeUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIController.GetGoalActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AFortAIController::GetGoalActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIController", "GetGoalActor");

	Params::FortAIController_GetGoalActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMcpProfileWorld.AbortDisintegration
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::AbortDisintegration(struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "AbortDisintegration");

	Params::FortMcpProfileWorld_AbortDisintegration Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.BatchUpdateInventory
// (Net, NetReliable, NetRequest, Native, Event, Protected, HasOutParams)
// Parameters:
// const struct FMcpProfileChangeRequest&  BatchUpdate                                            (Parm, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::BatchUpdateInventory(const struct FMcpProfileChangeRequest& BatchUpdate, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "BatchUpdateInventory");

	Params::FortMcpProfileWorld_BatchUpdateInventory Parms{};

	Parms.BatchUpdate = std::move(BatchUpdate);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.CreateOrUpgradeOutpostItem
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TemplateId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::CreateOrUpgradeOutpostItem(const class FString& TemplateId, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "CreateOrUpgradeOutpostItem");

	Params::FortMcpProfileWorld_CreateOrUpgradeOutpostItem Parms{};

	Parms.TemplateId = std::move(TemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.DepositPostResources
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            itemsToDepositIds                                      (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    itemCountsToDeposit                                    (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::DepositPostResources(const TArray<class FString>& itemsToDepositIds, const TArray<int32>& itemCountsToDeposit, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "DepositPostResources");

	Params::FortMcpProfileWorld_DepositPostResources Parms{};

	Parms.itemsToDepositIds = std::move(itemsToDepositIds);
	Parms.itemCountsToDeposit = std::move(itemCountsToDeposit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.DisintegrateItems
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const TArray<class FString>&            itemsToDisintegrateIds                                 (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    itemCountsToDisintegrate                               (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::DisintegrateItems(const TArray<class FString>& itemsToDisintegrateIds, const TArray<int32>& itemCountsToDisintegrate, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "DisintegrateItems");

	Params::FortMcpProfileWorld_DisintegrateItems Parms{};

	Parms.itemsToDisintegrateIds = std::move(itemsToDisintegrateIds);
	Parms.itemCountsToDisintegrate = std::move(itemCountsToDisintegrate);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.FabricateItem
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// const class FString&                    TemplateId                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::FabricateItem(const class FString& TemplateId, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "FabricateItem");

	Params::FortMcpProfileWorld_FabricateItem Parms{};

	Parms.TemplateId = std::move(TemplateId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.IncreaseOutpostPrestige
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::IncreaseOutpostPrestige(struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "IncreaseOutpostPrestige");

	Params::FortMcpProfileWorld_IncreaseOutpostPrestige Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.InitializeTheater
// (Net, NetReliable, NetRequest, Native, Event, Protected, HasOutParams)
// Parameters:
// const class FString&                    TheaterGuid                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::InitializeTheater(const class FString& TheaterGuid, struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "InitializeTheater");

	Params::FortMcpProfileWorld_InitializeTheater Parms{};

	Parms.TheaterGuid = std::move(TheaterGuid);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMcpProfileWorld.MarkOutpostDefended
// (Net, NetReliable, NetRequest, Native, Event, Public, HasOutParams)
// Parameters:
// struct FDedicatedServerUrlContext*      Context                                                (Parm, OutParm, RepSkip, NativeAccessSpecifierPublic)

void UFortMcpProfileWorld::MarkOutpostDefended(struct FDedicatedServerUrlContext* Context)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMcpProfileWorld", "MarkOutpostDefended");

	Params::FortMcpProfileWorld_MarkOutpostDefended Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Context != nullptr)
		*Context = std::move(Parms.Context);
}


// Function FortniteGame.FortMission.SpawnAtPlacementActorsAsArray
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class AFortMission*                     Mission                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bSucceeded                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> AFortMission::SpawnAtPlacementActorsAsArray(class AFortMission* Mission, bool* bSucceeded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortMission", "SpawnAtPlacementActorsAsArray");

	Params::FortMission_SpawnAtPlacementActorsAsArray Parms{};

	Parms.Mission = Mission;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bSucceeded != nullptr)
		*bSucceeded = Parms.bSucceeded;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.AddGoalsToAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UFortAIAssignment*                Assignment                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAIGoalInfo>&   GoalInfos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::AddGoalsToAssignment(class UFortAIAssignment* Assignment, const TArray<struct FFortAIGoalInfo>& GoalInfos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "AddGoalsToAssignment");

	Params::FortMission_AddGoalsToAssignment Parms{};

	Parms.Assignment = Assignment;
	Parms.GoalInfos = std::move(GoalInfos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.AddGoalsToEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAIGoalInfo>&   GoalInfos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::AddGoalsToEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter, const TArray<struct FFortAIGoalInfo>& GoalInfos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "AddGoalsToEncounterAssignment");

	Params::FortMission_AddGoalsToEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;
	Parms.GoalInfos = std::move(GoalInfos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.AddGoalToAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UFortAIAssignment*                Assignment                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIGoalInfo&           GoalInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::AddGoalToAssignment(class UFortAIAssignment* Assignment, const struct FFortAIGoalInfo& GoalInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "AddGoalToAssignment");

	Params::FortMission_AddGoalToAssignment Parms{};

	Parms.Assignment = Assignment;
	Parms.GoalInfo = std::move(GoalInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.AddGoalToEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIGoalInfo&           GoalInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::AddGoalToEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter, const struct FFortAIGoalInfo& GoalInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "AddGoalToEncounterAssignment");

	Params::FortMission_AddGoalToEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;
	Parms.GoalInfo = std::move(GoalInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.AttemptMissionSave
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    OptionalSaveName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::AttemptMissionSave(const class FString& OptionalSaveName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "AttemptMissionSave");

	Params::FortMission_AttemptMissionSave Parms{};

	Parms.OptionalSaveName = std::move(OptionalSaveName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.BlueprintCustomHandleMissionEvent
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FGuid&                     MissionGuid_0                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// class UFortMissionEventParams*          Params_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    DO_NOT_USE_THIS_OR_VARIABLES_BELOW                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UDataAsset*                 EventContent                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EventInstigator                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GenericInt                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GenericFloat                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      GenericText                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     GameplayTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::BlueprintCustomHandleMissionEvent(const struct FGuid& MissionGuid_0, const struct FGameplayTagContainer& ObjectiveHandle, class UFortMissionEventParams* Params_0, bool DO_NOT_USE_THIS_OR_VARIABLES_BELOW, class UObject* EventFocus, const class UDataAsset* EventContent, class AActor* EventInstigator, int32 GenericInt, float GenericFloat, const class FText& GenericText, const struct FGameplayTagContainer& GameplayTags, const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintCustomHandleMissionEvent");

	Params::FortMission_BlueprintCustomHandleMissionEvent Parms{};

	Parms.MissionGuid_0 = std::move(MissionGuid_0);
	Parms.ObjectiveHandle = std::move(ObjectiveHandle);
	Parms.Params_0 = Params_0;
	Parms.DO_NOT_USE_THIS_OR_VARIABLES_BELOW = DO_NOT_USE_THIS_OR_VARIABLES_BELOW;
	Parms.EventFocus = EventFocus;
	Parms.EventContent = EventContent;
	Parms.EventInstigator = EventInstigator;
	Parms.GenericInt = GenericInt;
	Parms.GenericFloat = GenericFloat;
	Parms.GenericText = std::move(GenericText);
	Parms.GameplayTags = std::move(GameplayTags);
	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMission.BlueprintHandleMissionEventNoReply
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::BlueprintHandleMissionEventNoReply(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintHandleMissionEventNoReply");

	Params::FortMission_BlueprintHandleMissionEventNoReply Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMission.BlueprintOnActivated
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::BlueprintOnActivated(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintOnActivated");

	Params::FortMission_BlueprintOnActivated Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMission.BlueprintOnMissionEnd
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// EFortMissionStatus                      Status                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::BlueprintOnMissionEnd(EFortMissionStatus Status)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintOnMissionEnd");

	Params::FortMission_BlueprintOnMissionEnd Parms{};

	Parms.Status = Status;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMission.BlueprintOnStartPlaying
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::BlueprintOnStartPlaying(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintOnStartPlaying");

	Params::FortMission_BlueprintOnStartPlaying Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMission.BlueprintPostMissionLoad
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)

void AFortMission::BlueprintPostMissionLoad()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "BlueprintPostMissionLoad");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortMission.ChooseRandomReward
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FFortMissionWeightedReward       ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortMissionWeightedReward AFortMission::ChooseRandomReward()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "ChooseRandomReward");

	Params::FortMission_ChooseRandomReward Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.CreateEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     AssignmentTags                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortAIGoalProvider>  GoalProvider                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortAIAssignmentIdentifier*     AssignmentIdentifier                                   (Parm, OutParm, NativeAccessSpecifierPublic)
// EAssignmentCreationResult               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAssignmentCreationResult AFortMission::CreateEncounterAssignment(const struct FGameplayTagContainer& AssignmentTags, const class UFortAIEncounterInfo*& Encounter, class UFortAIAssignmentSettings* AssignmentSettings, TSubclassOf<class UFortAIGoalProvider> GoalProvider, struct FFortAIAssignmentIdentifier* AssignmentIdentifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "CreateEncounterAssignment");

	Params::FortMission_CreateEncounterAssignment Parms{};

	Parms.AssignmentTags = std::move(AssignmentTags);
	Parms.Encounter = Encounter;
	Parms.AssignmentSettings = AssignmentSettings;
	Parms.GoalProvider = GoalProvider;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (AssignmentIdentifier != nullptr)
		*AssignmentIdentifier = std::move(Parms.AssignmentIdentifier);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.CreateEncounterSequence
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     SequenceTags                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortAIEncounterSequence*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterSequence* AFortMission::CreateEncounterSequence(const struct FGameplayTagContainer& SequenceTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "CreateEncounterSequence");

	Params::FortMission_CreateEncounterSequence Parms{};

	Parms.SequenceTags = std::move(SequenceTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.FindGoalLocationsForEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 OutGoalLocations                                       (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AFortMission::FindGoalLocationsForEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter, TArray<struct FVector>* OutGoalLocations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "FindGoalLocationsForEncounterAssignment");

	Params::FortMission_FindGoalLocationsForEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutGoalLocations != nullptr)
		*OutGoalLocations = std::move(Parms.OutGoalLocations);
}


// Function FortniteGame.FortMission.FocusThisMission
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bTemporaryFocus                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortMission::FocusThisMission(bool bTemporaryFocus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "FocusThisMission");

	Params::FortMission_FocusThisMission Parms{};

	Parms.bTemporaryFocus = bTemporaryFocus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.GetConfigData
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              InBucketTag                                            (Parm, NativeAccessSpecifierPublic)
// class UFortMissionConfigData*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortMissionConfigData* AFortMission::GetConfigData(const struct FGameplayTag& InBucketTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetConfigData");

	Params::FortMission_GetConfigData Parms{};

	Parms.InBucketTag = std::move(InBucketTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GrantRewardsByTag
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              RewardTag                                              (ConstParm, Parm, NativeAccessSpecifierPublic)
// EFortRewardType                         RewardType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::GrantRewardsByTag(const struct FGameplayTag& RewardTag, EFortRewardType RewardType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GrantRewardsByTag");

	Params::FortMission_GrantRewardsByTag Parms{};

	Parms.RewardTag = std::move(RewardTag);
	Parms.RewardType = RewardType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.OnMatchStarted
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortMission::OnMatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "OnMatchStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortMission.OnRep_bIsMissionVisible
// (Native, Protected)

void AFortMission::OnRep_bIsMissionVisible()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "OnRep_bIsMissionVisible");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.OnRep_UIIndex
// (Native, Protected)

void AFortMission::OnRep_UIIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "OnRep_UIIndex");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.OnWorldReady
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortMission::OnWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "OnWorldReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortMission.RemoveEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::RemoveEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "RemoveEncounterAssignment");

	Params::FortMission_RemoveEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.RemoveGoalFromEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAIGoalInfo&           GoalInfo                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::RemoveGoalFromEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter, const struct FFortAIGoalInfo& GoalInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "RemoveGoalFromEncounterAssignment");

	Params::FortMission_RemoveGoalFromEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;
	Parms.GoalInfo = std::move(GoalInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.RemoveGoalsFromEncounterAssignment
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAIAssignmentIdentifier&AssignmentIdentifier                                   (Parm, NativeAccessSpecifierPublic)
// const class UFortAIEncounterInfo*&      Encounter                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAIGoalInfo>&   GoalInfos                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortMission::RemoveGoalsFromEncounterAssignment(const struct FFortAIAssignmentIdentifier& AssignmentIdentifier, const class UFortAIEncounterInfo*& Encounter, const TArray<struct FFortAIGoalInfo>& GoalInfos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "RemoveGoalsFromEncounterAssignment");

	Params::FortMission_RemoveGoalsFromEncounterAssignment Parms{};

	Parms.AssignmentIdentifier = std::move(AssignmentIdentifier);
	Parms.Encounter = Encounter;
	Parms.GoalInfos = std::move(GoalInfos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.SetToSilentDestroy
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortMission::SetToSilentDestroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "SetToSilentDestroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.SetUiVisibility
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsMissionVisible                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortMission::SetUiVisibility(bool bInIsMissionVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "SetUiVisibility");

	Params::FortMission_SetUiVisibility Parms{};

	Parms.bInIsMissionVisible = bInIsMissionVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.StartMissionAIEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            TargetActors                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEncounterEnvironmentQueryInfo&EnvironmentQueryInfo                                   (Parm, NativeAccessSpecifierPublic)
// class AActor*                           QueryActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InjectedTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortEncounterSettings&    EncounterSettings                                      (Parm, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* AFortMission::StartMissionAIEncounter(TSubclassOf<class UFortAIEncounterInfo> EncounterTemplate, const TArray<class AActor*>& TargetActors, class UFortAIAssignmentSettings* AssignmentSettings, const struct FEncounterEnvironmentQueryInfo& EnvironmentQueryInfo, class AActor* QueryActor, const struct FGameplayTagContainer& InjectedTags, const struct FFortEncounterSettings& EncounterSettings, int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "StartMissionAIEncounter");

	Params::FortMission_StartMissionAIEncounter Parms{};

	Parms.EncounterTemplate = EncounterTemplate;
	Parms.TargetActors = std::move(TargetActors);
	Parms.AssignmentSettings = AssignmentSettings;
	Parms.EnvironmentQueryInfo = std::move(EnvironmentQueryInfo);
	Parms.QueryActor = QueryActor;
	Parms.InjectedTags = std::move(InjectedTags);
	Parms.EncounterSettings = std::move(EncounterSettings);
	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.StartMissionAIEncounterFromGeneratedProfile
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// int32                                   GeneratedEncounterProfileIndex                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            TargetActors                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEncounterEnvironmentQueryInfo&EnvironmentQueryInfo                                   (Parm, NativeAccessSpecifierPublic)
// class AActor*                           QueryActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InjectedTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortEncounterSettings&    EncounterSettings                                      (Parm, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* AFortMission::StartMissionAIEncounterFromGeneratedProfile(int32 GeneratedEncounterProfileIndex, const TArray<class AActor*>& TargetActors, class UFortAIAssignmentSettings* AssignmentSettings, const struct FEncounterEnvironmentQueryInfo& EnvironmentQueryInfo, class AActor* QueryActor, const struct FGameplayTagContainer& InjectedTags, const struct FFortEncounterSettings& EncounterSettings, int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "StartMissionAIEncounterFromGeneratedProfile");

	Params::FortMission_StartMissionAIEncounterFromGeneratedProfile Parms{};

	Parms.GeneratedEncounterProfileIndex = GeneratedEncounterProfileIndex;
	Parms.TargetActors = std::move(TargetActors);
	Parms.AssignmentSettings = AssignmentSettings;
	Parms.EnvironmentQueryInfo = std::move(EnvironmentQueryInfo);
	Parms.QueryActor = QueryActor;
	Parms.InjectedTags = std::move(InjectedTags);
	Parms.EncounterSettings = std::move(EncounterSettings);
	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.StartMissionNotification
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// TSubclassOf<class AFortClientNotification>Notification                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerController*            SpecificPlayer                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      OverrideDisplayText                                    (Parm, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn1                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  OptionalPlayerPawn2                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             OptionalActionName                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class USoundBase*                 OptionalSound                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTreatAsUnique                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bCancelActiveNotification                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bWaitForClients                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortMission::StartMissionNotification(const struct FLatentActionInfo& LatentInfo, TSubclassOf<class AFortClientNotification> Notification, class AFortPlayerController* SpecificPlayer, const class FText& OverrideDisplayText, class AFortPlayerPawn* OptionalPlayerPawn1, class AFortPlayerPawn* OptionalPlayerPawn2, class FName OptionalActionName, const class USoundBase* OptionalSound, bool bTreatAsUnique, bool bCancelActiveNotification, bool bWaitForClients)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "StartMissionNotification");

	Params::FortMission_StartMissionNotification Parms{};

	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Notification = Notification;
	Parms.SpecificPlayer = SpecificPlayer;
	Parms.OverrideDisplayText = std::move(OverrideDisplayText);
	Parms.OptionalPlayerPawn1 = OptionalPlayerPawn1;
	Parms.OptionalPlayerPawn2 = OptionalPlayerPawn2;
	Parms.OptionalActionName = OptionalActionName;
	Parms.OptionalSound = OptionalSound;
	Parms.bTreatAsUnique = bTreatAsUnique;
	Parms.bCancelActiveNotification = bCancelActiveNotification;
	Parms.bWaitForClients = bWaitForClients;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.StopEncounterSequence
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIEncounterSequence*         SequenceToStop                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::StopEncounterSequence(class UFortAIEncounterSequence* SequenceToStop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "StopEncounterSequence");

	Params::FortMission_StopEncounterSequence Parms{};

	Parms.SequenceToStop = SequenceToStop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.StopMissionAIEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIEncounterInfo*             EncounterToStop                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::StopMissionAIEncounter(class UFortAIEncounterInfo* EncounterToStop)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "StopMissionAIEncounter");

	Params::FortMission_StopMissionAIEncounter Parms{};

	Parms.EncounterToStop = EncounterToStop;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMission.GetBuildingDamageLootTier
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortMission::GetBuildingDamageLootTier(class AFortPlayerController* PlayerController) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetBuildingDamageLootTier");

	Params::FortMission_GetBuildingDamageLootTier Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetCurrentBluGloRewards
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortMission::GetCurrentBluGloRewards() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetCurrentBluGloRewards");

	Params::FortMission_GetCurrentBluGloRewards Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetDefaultAssignmentForEncounter
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             Encounter                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignment**               DefaultAssignment                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMission::GetDefaultAssignmentForEncounter(class UFortAIEncounterInfo* Encounter, class UFortAIAssignment** DefaultAssignment) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetDefaultAssignmentForEncounter");

	Params::FortMission_GetDefaultAssignmentForEncounter Parms{};

	Parms.Encounter = Encounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (DefaultAssignment != nullptr)
		*DefaultAssignment = Parms.DefaultAssignment;
}


// Function FortniteGame.FortMission.GetExpectedCompletionTime
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortMission::GetExpectedCompletionTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetExpectedCompletionTime");

	Params::FortMission_GetExpectedCompletionTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetMissionFortPlayerControllers
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AFortPlayerController*>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AFortPlayerController*> AFortMission::GetMissionFortPlayerControllers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetMissionFortPlayerControllers");

	Params::FortMission_GetMissionFortPlayerControllers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetMissionGuid
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGuid                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FGuid AFortMission::GetMissionGuid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetMissionGuid");

	Params::FortMission_GetMissionGuid Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetObjectiveByHandle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// class AFortObjectiveBase*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortObjectiveBase* AFortMission::GetObjectiveByHandle(const struct FGameplayTagContainer& ObjectiveHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetObjectiveByHandle");

	Params::FortMission_GetObjectiveByHandle Parms{};

	Parms.ObjectiveHandle = std::move(ObjectiveHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetObjectiveStatusByHandle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTagContainer&     ObjectiveHandle                                        (Parm, NativeAccessSpecifierPublic)
// EFortObjectiveStatus                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortObjectiveStatus AFortMission::GetObjectiveStatusByHandle(const struct FGameplayTagContainer& ObjectiveHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetObjectiveStatusByHandle");

	Params::FortMission_GetObjectiveStatusByHandle Parms{};

	Parms.ObjectiveHandle = std::move(ObjectiveHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetPawnDamageLootTier
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortMission::GetPawnDamageLootTier(class AFortPlayerController* PlayerController) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetPawnDamageLootTier");

	Params::FortMission_GetPawnDamageLootTier Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetPlayerBuildingDamage
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortMission::GetPlayerBuildingDamage(class AFortPlayerController* PlayerController) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetPlayerBuildingDamage");

	Params::FortMission_GetPlayerBuildingDamage Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMission.GetPlayerPawnDamage
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortMission::GetPlayerPawnDamage(class AFortPlayerController* PlayerController) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMission", "GetPlayerPawnDamage");

	Params::FortMission_GetPlayerPawnDamage Parms{};

	Parms.PlayerController = PlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPMission_EnemyBaseDestruction.GetCornerstoneForTeam
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortTeam                               InTeam                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPvPBaseCornerstone*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPvPBaseCornerstone* AFortPvPMission_EnemyBaseDestruction::GetCornerstoneForTeam(EFortTeam InTeam)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPvPMission_EnemyBaseDestruction", "GetCornerstoneForTeam");

	Params::FortPvPMission_EnemyBaseDestruction_GetCornerstoneForTeam Parms{};

	Parms.InTeam = InTeam;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPatrolWardInterface.GetAffectingDistance
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float IFortPatrolWardInterface::GetAffectingDistance() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPatrolWardInterface", "GetAffectingDistance");

	Params::FortPatrolWardInterface_GetAffectingDistance Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPatrolWardInterface.GetAffectingType
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent, Const)
// Parameters:
// EWardAffectType                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWardAffectType IFortPatrolWardInterface::GetAffectingType() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPatrolWardInterface", "GetAffectingType");

	Params::FortPatrolWardInterface_GetAffectingType Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirectorDataManager.TriggerEvent
// (Native, Public, HasOutParams)
// Parameters:
// const struct FFortAIDirectorEvent&      TriggeredEvent                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortAIDirectorDataManager::TriggerEvent(const struct FFortAIDirectorEvent& TriggeredEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirectorDataManager", "TriggerEvent");

	Params::FortAIDirectorDataManager_TriggerEvent Parms{};

	Parms.TriggeredEvent = std::move(TriggeredEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIDirectorDataManager.GetAIDirectorFactorValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAIDirectorFactor                   AIDirectorFactor                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIDirectorDataManager::GetAIDirectorFactorValue(EFortAIDirectorFactor AIDirectorFactor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirectorDataManager", "GetAIDirectorFactorValue");

	Params::FortAIDirectorDataManager_GetAIDirectorFactorValue Parms{};

	Parms.AIDirectorFactor = AIDirectorFactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIDirectorDataManager.GetGetAIDirectorEventValue
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortAIDirectorEvent                    Event                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortAIDirectorDataManager::GetGetAIDirectorEventValue(EFortAIDirectorEvent Event) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIDirectorDataManager", "GetGetAIDirectorEventValue");

	Params::FortAIDirectorDataManager_GetGetAIDirectorEventValue Parms{};

	Parms.Event = Event;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnerInterface.IsReadyToReceiveNewSpawnGroup
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortAISpawnerInterface::IsReadyToReceiveNewSpawnGroup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnerInterface", "IsReadyToReceiveNewSpawnGroup");

	Params::FortAISpawnerInterface_IsReadyToReceiveNewSpawnGroup Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnerInterface.OnReceiveSpawnGroup
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool IFortAISpawnerInterface::OnReceiveSpawnGroup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnerInterface", "OnReceiveSpawnGroup");

	Params::FortAISpawnerInterface_OnReceiveSpawnGroup Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.CreateEncounterAssignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           GoalActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIAssignment*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIAssignment* UFortAIEncounterInfo::CreateEncounterAssignment(class UFortAIAssignmentSettings* AssignmentSettings, class AActor* GoalActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "CreateEncounterAssignment");

	Params::FortAIEncounterInfo_CreateEncounterAssignment Parms{};

	Parms.AssignmentSettings = AssignmentSettings;
	Parms.GoalActor = GoalActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.EnemySpawnerGroupHasAIRemainingToSpawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           EnemySpawner                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterInfo::EnemySpawnerGroupHasAIRemainingToSpawn(class AActor* EnemySpawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "EnemySpawnerGroupHasAIRemainingToSpawn");

	Params::FortAIEncounterInfo_EnemySpawnerGroupHasAIRemainingToSpawn Parms{};

	Parms.EnemySpawner = EnemySpawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.GetEncounterDataManager
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIDirectorDataManager*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIDirectorDataManager* UFortAIEncounterInfo::GetEncounterDataManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "GetEncounterDataManager");

	Params::FortAIEncounterInfo_GetEncounterDataManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.GetEncounterTimeSeconds
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortAIEncounterInfo::GetEncounterTimeSeconds()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "GetEncounterTimeSeconds");

	Params::FortAIEncounterInfo_GetEncounterTimeSeconds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.GroupHasAIRemainingToSpawn
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAISpawnerData&        FortAISpawnerData                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterInfo::GroupHasAIRemainingToSpawn(const struct FFortAISpawnerData& FortAISpawnerData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "GroupHasAIRemainingToSpawn");

	Params::FortAIEncounterInfo_GroupHasAIRemainingToSpawn Parms{};

	Parms.FortAISpawnerData = std::move(FortAISpawnerData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.OnFadeStarted
// (Event, Public, BlueprintEvent)

void UFortAIEncounterInfo::OnFadeStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "OnFadeStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIEncounterInfo.OnGoalTakeDamage
// (Final, Native, Public, 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)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::OnGoalTakeDamage(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, class AActor* DamageCauser, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& Momentum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "OnGoalTakeDamage");

	Params::FortAIEncounterInfo_OnGoalTakeDamage Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.Momentum = std::move(Momentum);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.OnPeakStarted
// (Event, Public, BlueprintEvent)

void UFortAIEncounterInfo::OnPeakStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "OnPeakStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIEncounterInfo.OnRampStarted
// (Event, Public, BlueprintEvent)

void UFortAIEncounterInfo::OnRampStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "OnRampStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIEncounterInfo.OnRestStarted
// (Event, Public, BlueprintEvent)

void UFortAIEncounterInfo::OnRestStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "OnRestStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortAIEncounterInfo.RegisterAISpawner
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InAISpawner                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::RegisterAISpawner(class AActor* InAISpawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "RegisterAISpawner");

	Params::FortAIEncounterInfo_RegisterAISpawner Parms{};

	Parms.InAISpawner = InAISpawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.RequestActivation
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::RequestActivation(int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "RequestActivation");

	Params::FortAIEncounterInfo_RequestActivation Parms{};

	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.ReserveNextAIPawn
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortAISpawnerData&        FortAISpawnerData                                      (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FFortSpawnAIRequest*             FortAISpawnRequest                                     (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterInfo::ReserveNextAIPawn(const struct FFortAISpawnerData& FortAISpawnerData, struct FFortSpawnAIRequest* FortAISpawnRequest)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "ReserveNextAIPawn");

	Params::FortAIEncounterInfo_ReserveNextAIPawn Parms{};

	Parms.FortAISpawnerData = std::move(FortAISpawnerData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FortAISpawnRequest != nullptr)
		*FortAISpawnRequest = std::move(Parms.FortAISpawnRequest);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.SetEncounterActivationState
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEncounterActivityState                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::SetEncounterActivationState(bool bEncounterActivityState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "SetEncounterActivationState");

	Params::FortAIEncounterInfo_SetEncounterActivationState Parms{};

	Parms.bEncounterActivityState = bEncounterActivityState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.SpawnAIGroup
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UFortAISpawnGroup*          SpawnGroupToSpawn                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AActor*                           SpawnSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UFortAbilitySet*>&   AbilitySetsToGrantOnSpawn                              (ConstParm, Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    bAllowAssigningToExternalSpawners                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   SecondsBetweenSpawns                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::SpawnAIGroup(const class UFortAISpawnGroup* SpawnGroupToSpawn, const struct FVector& SpawnLocation, const struct FRotator& SpawnRotation, class AActor* SpawnSource, const TArray<class UFortAbilitySet*>& AbilitySetsToGrantOnSpawn, bool bAllowAssigningToExternalSpawners, float SecondsBetweenSpawns)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "SpawnAIGroup");

	Params::FortAIEncounterInfo_SpawnAIGroup Parms{};

	Parms.SpawnGroupToSpawn = SpawnGroupToSpawn;
	Parms.SpawnLocation = std::move(SpawnLocation);
	Parms.SpawnRotation = std::move(SpawnRotation);
	Parms.SpawnSource = SpawnSource;
	Parms.AbilitySetsToGrantOnSpawn = std::move(AbilitySetsToGrantOnSpawn);
	Parms.bAllowAssigningToExternalSpawners = bAllowAssigningToExternalSpawners;
	Parms.SecondsBetweenSpawns = SecondsBetweenSpawns;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.SpawnAIPawnReservedForEnemySpawner
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           EnemySpawner                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortAIPawn*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIPawn* UFortAIEncounterInfo::SpawnAIPawnReservedForEnemySpawner(class AActor* EnemySpawner, const struct FVector& SpawnLocation, const struct FRotator& SpawnRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "SpawnAIPawnReservedForEnemySpawner");

	Params::FortAIEncounterInfo_SpawnAIPawnReservedForEnemySpawner Parms{};

	Parms.EnemySpawner = EnemySpawner;
	Parms.SpawnLocation = std::move(SpawnLocation);
	Parms.SpawnRotation = std::move(SpawnRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.UnRegisterAISpawner
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InAISpawner                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAIEncounterInfo::UnRegisterAISpawner(class AActor* InAISpawner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "UnRegisterAISpawner");

	Params::FortAIEncounterInfo_UnRegisterAISpawner Parms{};

	Parms.InAISpawner = InAISpawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterInfo.EncounterHasReservedSpawnRequestForEnemySpawner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           EnemySpawner                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterInfo::EncounterHasReservedSpawnRequestForEnemySpawner(class AActor* EnemySpawner) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "EncounterHasReservedSpawnRequestForEnemySpawner");

	Params::FortAIEncounterInfo_EncounterHasReservedSpawnRequestForEnemySpawner Parms{};

	Parms.EnemySpawner = EnemySpawner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterInfo.GetCurrentSpawnAreaDirections
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<EFortEncounterDirection>*        OutDirections                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterInfo::GetCurrentSpawnAreaDirections(TArray<EFortEncounterDirection>* OutDirections) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterInfo", "GetCurrentSpawnAreaDirections");

	Params::FortAIEncounterInfo_GetCurrentSpawnAreaDirections Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDirections != nullptr)
		*OutDirections = std::move(Parms.OutDirections);

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetRelevantCloudMeshes
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             SourceCloudMeshComponent                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BoundingBoxPadding                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UStaticMeshComponent*>*    OutInfluencingCloudMeshComponents                      (Parm, OutParm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AThreatCloud::GetRelevantCloudMeshes(class UStaticMeshComponent* SourceCloudMeshComponent, float BoundingBoxPadding, TArray<class UStaticMeshComponent*>* OutInfluencingCloudMeshComponents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetRelevantCloudMeshes");

	Params::ThreatCloud_GetRelevantCloudMeshes Parms{};

	Parms.SourceCloudMeshComponent = SourceCloudMeshComponent;
	Parms.BoundingBoxPadding = BoundingBoxPadding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutInfluencingCloudMeshComponents != nullptr)
		*OutInfluencingCloudMeshComponents = std::move(Parms.OutInfluencingCloudMeshComponents);
}


// Function FortniteGame.ThreatCloud.OnBeginDeath
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnBeginDeath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnBeginDeath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.OnCloudActivated
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnCloudActivated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnCloudActivated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.OnCloudDeactivated
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortThreatDeactivationType             DeactivationType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeactivationDuration                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AThreatCloud::OnCloudDeactivated(EFortThreatDeactivationType DeactivationType, float DeactivationDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnCloudDeactivated");

	Params::ThreatCloud_OnCloudDeactivated Parms{};

	Parms.DeactivationType = DeactivationType;
	Parms.DeactivationDuration = DeactivationDuration;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.ThreatCloud.OnCloudInfluenceCalculated
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnCloudInfluenceCalculated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnCloudInfluenceCalculated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.OnCloudScaleChanged
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// class UStaticMeshComponent*             MeshInfluenced                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         MIDInfluenced                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             MeshInfluencer                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InfluencerScale                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InfluencerScalePercentage                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InfluencerIndex                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AThreatCloud::OnCloudScaleChanged(class UStaticMeshComponent* MeshInfluenced, class UMaterialInstanceDynamic* MIDInfluenced, class UStaticMeshComponent* MeshInfluencer, const struct FVector& InfluencerScale, float InfluencerScalePercentage, int32 InfluencerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnCloudScaleChanged");

	Params::ThreatCloud_OnCloudScaleChanged Parms{};

	Parms.MeshInfluenced = MeshInfluenced;
	Parms.MIDInfluenced = MIDInfluenced;
	Parms.MeshInfluencer = MeshInfluencer;
	Parms.InfluencerScale = std::move(InfluencerScale);
	Parms.InfluencerScalePercentage = InfluencerScalePercentage;
	Parms.InfluencerIndex = InfluencerIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.ThreatCloud.OnCloudStart
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnCloudStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnCloudStart");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.OnLightningStrike
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   EndLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class ABuildingRift*                    Rift                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLightningStruckRift                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AThreatCloud::OnLightningStrike(const struct FVector& StartLocation, const struct FVector& EndLocation, class ABuildingRift* Rift, bool bLightningStruckRift)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnLightningStrike");

	Params::ThreatCloud_OnLightningStrike Parms{};

	Parms.StartLocation = std::move(StartLocation);
	Parms.EndLocation = std::move(EndLocation);
	Parms.Rift = Rift;
	Parms.bLightningStruckRift = bLightningStruckRift;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.ThreatCloud.OnNeighborChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   NeighborIndex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AThreatCloud::OnNeighborChanged(int32 NeighborIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnNeighborChanged");

	Params::ThreatCloud_OnNeighborChanged Parms{};

	Parms.NeighborIndex = NeighborIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.ThreatCloud.OnNeighborsChanged
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// bool                                    bPrimaryNeighborsChanged                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bSecondaryNeighborsChanged                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<int32>&                    IndicesOfNewImmediateNeighbors                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<int32>&                    IndicesOfDyingImmediateNeighbors                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AThreatCloud::OnNeighborsChanged(bool bPrimaryNeighborsChanged, bool bSecondaryNeighborsChanged, const TArray<int32>& IndicesOfNewImmediateNeighbors, const TArray<int32>& IndicesOfDyingImmediateNeighbors)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnNeighborsChanged");

	Params::ThreatCloud_OnNeighborsChanged Parms{};

	Parms.bPrimaryNeighborsChanged = bPrimaryNeighborsChanged;
	Parms.bSecondaryNeighborsChanged = bSecondaryNeighborsChanged;
	Parms.IndicesOfNewImmediateNeighbors = std::move(IndicesOfNewImmediateNeighbors);
	Parms.IndicesOfDyingImmediateNeighbors = std::move(IndicesOfDyingImmediateNeighbors);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.ThreatCloud.OnNumSecondaryNeighborsChanged
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnNumSecondaryNeighborsChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnNumSecondaryNeighborsChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.OnThreatVolumeChanged
// (Event, Public, BlueprintEvent)

void AThreatCloud::OnThreatVolumeChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "OnThreatVolumeChanged");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ThreatCloud.SetCloudInfluenceInfo
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UStaticMeshComponent*>&CloudStaticMeshComponents                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           FinalCloudScales                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<class UMaterialInstanceDynamic*>&CloudMIDs                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   BoundingBoxPadding                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AThreatCloud::SetCloudInfluenceInfo(const TArray<class UStaticMeshComponent*>& CloudStaticMeshComponents, const TArray<struct FVector>& FinalCloudScales, const TArray<class UMaterialInstanceDynamic*>& CloudMIDs, float BoundingBoxPadding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "SetCloudInfluenceInfo");

	Params::ThreatCloud_SetCloudInfluenceInfo Parms{};

	Parms.CloudStaticMeshComponents = std::move(CloudStaticMeshComponents);
	Parms.FinalCloudScales = std::move(FinalCloudScales);
	Parms.CloudMIDs = std::move(CloudMIDs);
	Parms.BoundingBoxPadding = BoundingBoxPadding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.ThreatCloud.SetCloudMeshAndScaleValues
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UStaticMeshComponent*>&CloudStaticMeshComponents                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bIncludeNegativeValues                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           FinalCloudScales                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AThreatCloud::SetCloudMeshAndScaleValues(const TArray<class UStaticMeshComponent*>& CloudStaticMeshComponents, bool bIncludeNegativeValues, const TArray<struct FVector>& FinalCloudScales)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "SetCloudMeshAndScaleValues");

	Params::ThreatCloud_SetCloudMeshAndScaleValues Parms{};

	Parms.CloudStaticMeshComponents = std::move(CloudStaticMeshComponents);
	Parms.bIncludeNegativeValues = bIncludeNegativeValues;
	Parms.FinalCloudScales = std::move(FinalCloudScales);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.ThreatCloud.SetCloudMeshScale
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             CloudStaticMesh                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AThreatCloud::SetCloudMeshScale(class UStaticMeshComponent* CloudStaticMesh, const struct FVector& Scale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "SetCloudMeshScale");

	Params::ThreatCloud_SetCloudMeshScale Parms{};

	Parms.CloudStaticMesh = CloudStaticMesh;
	Parms.Scale = std::move(Scale);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.ThreatCloud.UpdateCloudBuildUp
// (Final, Native, Public)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::UpdateCloudBuildUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "UpdateCloudBuildUp");

	Params::ThreatCloud_UpdateCloudBuildUp Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetCloudBuildUpPercentage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::GetCloudBuildUpPercentage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetCloudBuildUpPercentage");

	Params::ThreatCloud_GetCloudBuildUpPercentage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetGoalActorLocations
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FVector>*                 OutGoalActorLocations                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AThreatCloud::GetGoalActorLocations(TArray<struct FVector>* OutGoalActorLocations) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetGoalActorLocations");

	Params::ThreatCloud_GetGoalActorLocations Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutGoalActorLocations != nullptr)
		*OutGoalActorLocations = std::move(Parms.OutGoalActorLocations);
}


// Function FortniteGame.ThreatCloud.GetNeighborCloudIndices
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<int32>*                          NeighborCloudIndices                                   (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AThreatCloud::GetNeighborCloudIndices(TArray<int32>* NeighborCloudIndices) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetNeighborCloudIndices");

	Params::ThreatCloud_GetNeighborCloudIndices Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NeighborCloudIndices != nullptr)
		*NeighborCloudIndices = std::move(Parms.NeighborCloudIndices);
}


// Function FortniteGame.ThreatCloud.GetNeighborClouds
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class AThreatCloud*>*            NeighborClouds                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AThreatCloud::GetNeighborClouds(TArray<class AThreatCloud*>* NeighborClouds) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetNeighborClouds");

	Params::ThreatCloud_GetNeighborClouds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (NeighborClouds != nullptr)
		*NeighborClouds = std::move(Parms.NeighborClouds);
}


// Function FortniteGame.ThreatCloud.GetNumberOfImmediateNeighbors
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    bHorizontalAndVertical                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bDiagonal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AThreatCloud::GetNumberOfImmediateNeighbors(bool bHorizontalAndVertical, bool bDiagonal) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetNumberOfImmediateNeighbors");

	Params::ThreatCloud_GetNumberOfImmediateNeighbors Parms{};

	Parms.bHorizontalAndVertical = bHorizontalAndVertical;
	Parms.bDiagonal = bDiagonal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetNumberOfSecondaryNeighbors
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AThreatCloud::GetNumberOfSecondaryNeighbors() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetNumberOfSecondaryNeighbors");

	Params::ThreatCloud_GetNumberOfSecondaryNeighbors Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetRandomFloat1
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::GetRandomFloat1() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetRandomFloat1");

	Params::ThreatCloud_GetRandomFloat1 Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetRandomFloat2
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::GetRandomFloat2() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetRandomFloat2");

	Params::ThreatCloud_GetRandomFloat2 Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetRandomFloat3
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::GetRandomFloat3() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetRandomFloat3");

	Params::ThreatCloud_GetRandomFloat3 Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetRandomFloat4
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AThreatCloud::GetRandomFloat4() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetRandomFloat4");

	Params::ThreatCloud_GetRandomFloat4 Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ThreatCloud.GetThreatVolume
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FBox                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FBox AThreatCloud::GetThreatVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ThreatCloud", "GetThreatVolume");

	Params::ThreatCloud_GetThreatVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.BroadcastExplosion
// (Net, Native, Event, NetMulticast, Protected)
// Parameters:
// const TArray<class AActor*>&            HitActors                                              (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FHitResult>&        HitResults                                             (ConstParm, Parm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::BroadcastExplosion(const TArray<class AActor*>& HitActors, const TArray<struct FHitResult>& HitResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "BroadcastExplosion");

	Params::FortGameplayEffectDeliveryActor_BroadcastExplosion Parms{};

	Parms.HitActors = std::move(HitActors);
	Parms.HitResults = std::move(HitResults);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.DoExplosion
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortGameplayEffectDeliveryActor::DoExplosion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "DoExplosion");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.Kill
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void AFortGameplayEffectDeliveryActor::Kill()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "Kill");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.KillTimerExpired
// (Native, Protected)

void AFortGameplayEffectDeliveryActor::KillTimerExpired()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "KillTimerExpired");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.OnComponentOverlap
// (Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::OnComponentOverlap(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("FortGameplayEffectDeliveryActor", "OnComponentOverlap");

	Params::FortGameplayEffectDeliveryActor_OnComponentOverlap Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.OnComponentTouch
// (Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::OnComponentTouch(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("FortGameplayEffectDeliveryActor", "OnComponentTouch");

	Params::FortGameplayEffectDeliveryActor_OnComponentTouch Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.OnExploded
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<class AActor*>&            HitActors                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const TArray<struct FHitResult>&        HitResults                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::OnExploded(const TArray<class AActor*>& HitActors, const TArray<struct FHitResult>& HitResults)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "OnExploded");

	Params::FortGameplayEffectDeliveryActor_OnExploded Parms{};

	Parms.HitActors = std::move(HitActors);
	Parms.HitResults = std::move(HitResults);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.OnRep_IsBeingKilled
// (Native, Protected)

void AFortGameplayEffectDeliveryActor::OnRep_IsBeingKilled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "OnRep_IsBeingKilled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.OnTouched
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::OnTouched(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FHitResult& HitResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "OnTouched");

	Params::FortGameplayEffectDeliveryActor_OnTouched Parms{};

	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.HitResult = std::move(HitResult);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.SetCollisionComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              NewCollisionComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::SetCollisionComponent(class UPrimitiveComponent* NewCollisionComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "SetCollisionComponent");

	Params::FortGameplayEffectDeliveryActor_SetCollisionComponent Parms{};

	Parms.NewCollisionComponent = NewCollisionComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.SetIgnoreInstigatorCollision
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldIgnore                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortGameplayEffectDeliveryActor::SetIgnoreInstigatorCollision(bool bShouldIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "SetIgnoreInstigatorCollision");

	Params::FortGameplayEffectDeliveryActor_SetIgnoreInstigatorCollision Parms{};

	Parms.bShouldIgnore = bShouldIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.GetCollisionComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UPrimitiveComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UPrimitiveComponent* AFortGameplayEffectDeliveryActor::GetCollisionComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "GetCollisionComponent");

	Params::FortGameplayEffectDeliveryActor_GetCollisionComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayEffectDeliveryActor.IsBeingKilled
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortGameplayEffectDeliveryActor::IsBeingKilled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayEffectDeliveryActor", "IsBeingKilled");

	Params::FortGameplayEffectDeliveryActor_IsBeingKilled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortProjectileBase.HasStoppedMoving
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortProjectileBase::HasStoppedMoving()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "HasStoppedMoving");

	Params::FortProjectileBase_HasStoppedMoving Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortProjectileBase.OnBounce
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortProjectileBase::OnBounce(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnBounce");

	Params::FortProjectileBase_OnBounce Parms{};

	Parms.Hit = std::move(Hit);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortProjectileBase.OnBounceCallback
// (Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   ImpactVelocity                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortProjectileBase::OnBounceCallback(const struct FHitResult& Hit, const struct FVector& ImpactVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnBounceCallback");

	Params::FortProjectileBase_OnBounceCallback Parms{};

	Parms.Hit = std::move(Hit);
	Parms.ImpactVelocity = std::move(ImpactVelocity);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortProjectileBase.OnRep_GravityScale
// (Final, Native, Public)

void AFortProjectileBase::OnRep_GravityScale()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnRep_GravityScale");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortProjectileBase.OnRep_ReplicatedMaxSpeed
// (Final, Native, Public)

void AFortProjectileBase::OnRep_ReplicatedMaxSpeed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnRep_ReplicatedMaxSpeed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortProjectileBase.OnStop
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortProjectileBase::OnStop(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnStop");

	Params::FortProjectileBase_OnStop Parms{};

	Parms.Hit = std::move(Hit);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortProjectileBase.OnStopCallback
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AFortProjectileBase::OnStopCallback(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "OnStopCallback");

	Params::FortProjectileBase_OnStopCallback Parms{};

	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortProjectileBase.SetGravityScale
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InitialGravityScale                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortProjectileBase::SetGravityScale(float InitialGravityScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "SetGravityScale");

	Params::FortProjectileBase_SetGravityScale Parms{};

	Parms.InitialGravityScale = InitialGravityScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortProjectileBase.GetGravityScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortProjectileBase::GetGravityScale() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectileBase", "GetGravityScale");

	Params::FortProjectileBase_GetGravityScale Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortProjectile_MOBATurret.OnHomingTargetDied
// (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)
// class AActor*                           DamageCauser                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   HitLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              FHitComponent                                          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Momentum                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortProjectile_MOBATurret::OnHomingTargetDied(class AActor* DamagedActor, float Damage, class AController* InstigatedBy, class AActor* DamageCauser, const struct FVector& HitLocation, class UPrimitiveComponent* FHitComponent, class FName BoneName, const struct FVector& Momentum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortProjectile_MOBATurret", "OnHomingTargetDied");

	Params::FortProjectile_MOBATurret_OnHomingTargetDied Parms{};

	Parms.DamagedActor = DamagedActor;
	Parms.Damage = Damage;
	Parms.InstigatedBy = InstigatedBy;
	Parms.DamageCauser = DamageCauser;
	Parms.HitLocation = std::move(HitLocation);
	Parms.FHitComponent = FHitComponent;
	Parms.BoneName = BoneName;
	Parms.Momentum = std::move(Momentum);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.ActivateThreatClouds
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const TArray<struct FThreatGridIndex>&  GridIndices                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortThreatVisualsManager::ActivateThreatClouds(const TArray<struct FThreatGridIndex>& GridIndices)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "ActivateThreatClouds");

	Params::FortThreatVisualsManager_ActivateThreatClouds Parms{};

	Parms.GridIndices = std::move(GridIndices);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.BeginThreatVisualsPrecursor
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// class AActor*                           SourceActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ThreatLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortThreatVisualsManager::BeginThreatVisualsPrecursor(class AActor* SourceActor, const struct FVector& ThreatLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "BeginThreatVisualsPrecursor");

	Params::FortThreatVisualsManager_BeginThreatVisualsPrecursor Parms{};

	Parms.SourceActor = SourceActor;
	Parms.ThreatLocation = std::move(ThreatLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.DeactivateThreatClouds
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// EFortThreatDeactivationType             DeactivationType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FThreatGridIndex>&  GridIndices                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   DeactivationDuration                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortThreatVisualsManager::DeactivateThreatClouds(EFortThreatDeactivationType DeactivationType, const TArray<struct FThreatGridIndex>& GridIndices, float DeactivationDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "DeactivateThreatClouds");

	Params::FortThreatVisualsManager_DeactivateThreatClouds Parms{};

	Parms.DeactivationType = DeactivationType;
	Parms.GridIndices = std::move(GridIndices);
	Parms.DeactivationDuration = DeactivationDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.OnBeginThreatVisualsPrecursor
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AActor*                           SourceActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortThreatVisualsManager::OnBeginThreatVisualsPrecursor(class AActor* SourceActor, const struct FVector& EndLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "OnBeginThreatVisualsPrecursor");

	Params::FortThreatVisualsManager_OnBeginThreatVisualsPrecursor Parms{};

	Parms.SourceActor = SourceActor;
	Parms.EndLocation = std::move(EndLocation);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortThreatVisualsManager.OnRep_GoalActorLocations
// (Final, Native, Private)

void AFortThreatVisualsManager::OnRep_GoalActorLocations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "OnRep_GoalActorLocations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.OnRep_ThreatLocations
// (Final, Native, Private)

void AFortThreatVisualsManager::OnRep_ThreatLocations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "OnRep_ThreatLocations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.OnThreatCloudsChanged
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<struct FThreatLocationInfo>&ThreatLocationInfo                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortThreatVisualsManager::OnThreatCloudsChanged(const TArray<struct FThreatLocationInfo>& ThreatLocationInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "OnThreatCloudsChanged");

	Params::FortThreatVisualsManager_OnThreatCloudsChanged Parms{};

	Parms.ThreatLocationInfo = std::move(ThreatLocationInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortThreatVisualsManager.UpdateCloudBuildUp
// (Final, Native, Private)

void AFortThreatVisualsManager::UpdateCloudBuildUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "UpdateCloudBuildUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortThreatVisualsManager.GetThreatCloud
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FThreatLocationInfo&       ThreatLocInfo                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class AThreatCloud*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AThreatCloud* AFortThreatVisualsManager::GetThreatCloud(const struct FThreatLocationInfo& ThreatLocInfo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "GetThreatCloud");

	Params::FortThreatVisualsManager_GetThreatCloud Parms{};

	Parms.ThreatLocInfo = std::move(ThreatLocInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortThreatVisualsManager.GetThreatClouds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FThreatLocationInfo>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

const TArray<struct FThreatLocationInfo> AFortThreatVisualsManager::GetThreatClouds() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "GetThreatClouds");

	Params::FortThreatVisualsManager_GetThreatClouds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortThreatVisualsManager.StormsExist
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortThreatVisualsManager::StormsExist() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatVisualsManager", "StormsExist");

	Params::FortThreatVisualsManager_StormsExist Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.Next
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortEncounterSequenceResult            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortEncounterSequenceResult UFortAIEncounterSequence::Next()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "Next");

	Params::FortAIEncounterSequence_Next Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.Previous
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// EFortEncounterSequenceResult            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortEncounterSequenceResult UFortAIEncounterSequence::Previous()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "Previous");

	Params::FortAIEncounterSequence_Previous Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.StartCurrentEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EFortEncounterSequenceResult*           OutRequestResult                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            TargetActors                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UFortAIAssignmentSettings*        AssignmentSettings                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEncounterEnvironmentQueryInfo&OverrideEnvironmentQueryInfo                           (Parm, NativeAccessSpecifierPublic)
// class AActor*                           OptionalQueryActor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     InjectedTags                                           (Parm, NativeAccessSpecifierPublic)
// const struct FFortEncounterSettings&    EncounterSettings                                      (Parm, NativeAccessSpecifierPublic)
// int32                                   ActivationDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* UFortAIEncounterSequence::StartCurrentEncounter(EFortEncounterSequenceResult* OutRequestResult, const TArray<class AActor*>& TargetActors, class UFortAIAssignmentSettings* AssignmentSettings, const struct FEncounterEnvironmentQueryInfo& OverrideEnvironmentQueryInfo, class AActor* OptionalQueryActor, const struct FGameplayTagContainer& InjectedTags, const struct FFortEncounterSettings& EncounterSettings, int32 ActivationDelay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "StartCurrentEncounter");

	Params::FortAIEncounterSequence_StartCurrentEncounter Parms{};

	Parms.TargetActors = std::move(TargetActors);
	Parms.AssignmentSettings = AssignmentSettings;
	Parms.OverrideEnvironmentQueryInfo = std::move(OverrideEnvironmentQueryInfo);
	Parms.OptionalQueryActor = OptionalQueryActor;
	Parms.InjectedTags = std::move(InjectedTags);
	Parms.EncounterSettings = std::move(EncounterSettings);
	Parms.ActivationDelay = ActivationDelay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRequestResult != nullptr)
		*OutRequestResult = Parms.OutRequestResult;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.StopCurrentEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortAIEncounterSequence::StopCurrentEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "StopCurrentEncounter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIEncounterSequence.EncounterBelongsToSequence
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             InEncounter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterSequence::EncounterBelongsToSequence(class UFortAIEncounterInfo* InEncounter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "EncounterBelongsToSequence");

	Params::FortAIEncounterSequence_EncounterBelongsToSequence Parms{};

	Parms.InEncounter = InEncounter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.GetCurrentEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAIEncounterInfo*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAIEncounterInfo* UFortAIEncounterSequence::GetCurrentEncounter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "GetCurrentEncounter");

	Params::FortAIEncounterSequence_GetCurrentEncounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.GetEncounterIndexInSequence
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortAIEncounterSequence::GetEncounterIndexInSequence() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "GetEncounterIndexInSequence");

	Params::FortAIEncounterSequence_GetEncounterIndexInSequence Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.GetNumEncountersInSequence
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortAIEncounterSequence::GetNumEncountersInSequence() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "GetNumEncountersInSequence");

	Params::FortAIEncounterSequence_GetNumEncountersInSequence Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.HasEncounter
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterSequence::HasEncounter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "HasEncounter");

	Params::FortAIEncounterSequence_HasEncounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIEncounterSequence.IsOnFinalIndexInSequence
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAIEncounterSequence::IsOnFinalIndexInSequence() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIEncounterSequence", "IsOnFinalIndexInSequence");

	Params::FortAIEncounterSequence_IsOnFinalIndexInSequence Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAIFunctionLibrary.MakeNoiseEvent
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           NoiseMaker                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxRange                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAIFunctionLibrary::MakeNoiseEvent(class AActor* NoiseMaker, float MaxRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIFunctionLibrary", "MakeNoiseEvent");

	Params::FortAIFunctionLibrary_MakeNoiseEvent Parms{};

	Parms.NoiseMaker = NoiseMaker;
	Parms.MaxRange = MaxRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIFunctionLibrary.MakeNoiseEventAtLocation
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           NoiseMaker                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MaxRange                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NoiseLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortAIFunctionLibrary::MakeNoiseEventAtLocation(class AActor* NoiseMaker, float MaxRange, const struct FVector& NoiseLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAIFunctionLibrary", "MakeNoiseEventAtLocation");

	Params::FortAIFunctionLibrary_MakeNoiseEventAtLocation Parms{};

	Parms.NoiseMaker = NoiseMaker;
	Parms.MaxRange = MaxRange;
	Parms.NoiseLocation = std::move(NoiseLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAIRootAssignmentProviderInterface.GetRootAssignmentIdentifier
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FFortAIAssignmentIdentifierReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FFortAIAssignmentIdentifier IFortAIRootAssignmentProviderInterface::GetRootAssignmentIdentifier() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAIRootAssignmentProviderInterface", "GetRootAssignmentIdentifier");

	Params::FortAIRootAssignmentProviderInterface_GetRootAssignmentIdentifier Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnGroup.GetEnemy
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   EnemyIndex                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortAIPawnVariant>   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UFortAIPawnVariant> UFortAISpawnGroup::GetEnemy(int32 EnemyIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnGroup", "GetEnemy");

	Params::FortAISpawnGroup_GetEnemy Parms{};

	Parms.EnemyIndex = EnemyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnGroup.GetNumberOfEnemies
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortAISpawnGroup::GetNumberOfEnemies() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnGroup", "GetNumberOfEnemies");

	Params::FortAISpawnGroup_GetNumberOfEnemies Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnGroup.IsLargeSpawnGroup
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAISpawnGroup::IsLargeSpawnGroup() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnGroup", "IsLargeSpawnGroup");

	Params::FortAISpawnGroup_IsLargeSpawnGroup Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnGroup.IsPrototype
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAISpawnGroup::IsPrototype() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnGroup", "IsPrototype");

	Params::FortAISpawnGroup_IsPrototype Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISpawnGroup.IsValidForEnemySpawners
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAISpawnGroup::IsValidForEnemySpawners() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAISpawnGroup", "IsValidForEnemySpawners");

	Params::FortAISpawnGroup_IsValidForEnemySpawners Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISystem.IsInCone2D
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   ConeOrigin                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   ConeDirection                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   HalfAngle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationToCheck                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAISystem::IsInCone2D(const struct FVector& ConeOrigin, const struct FVector& ConeDirection, float HalfAngle, const struct FVector& LocationToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAISystem", "IsInCone2D");

	Params::FortAISystem_IsInCone2D Parms{};

	Parms.ConeOrigin = std::move(ConeOrigin);
	Parms.ConeDirection = std::move(ConeDirection);
	Parms.HalfAngle = HalfAngle;
	Parms.LocationToCheck = std::move(LocationToCheck);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAISystem.RequestNumberofBTDrivenAIPawns
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberOfPawns                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAISystem::RequestNumberofBTDrivenAIPawns(class UObject* WorldContext, int32 NumberOfPawns)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAISystem", "RequestNumberofBTDrivenAIPawns");

	Params::FortAISystem_RequestNumberofBTDrivenAIPawns Parms{};

	Parms.WorldContext = WorldContext;
	Parms.NumberOfPawns = NumberOfPawns;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostAnalytics.FireAnalyticsEvent_OutpostAttackWaveCompleted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingType                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             NumMissionsCompleted                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              Succeeded                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const class FString&                    Direction                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOutpostAnalytics::FireAnalyticsEvent_OutpostAttackWaveCompleted(const class UObject* SourceBp, const class FString& BuildingType, const int32 NumMissionsCompleted, const bool Succeeded, const class FString& Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostAnalytics", "FireAnalyticsEvent_OutpostAttackWaveCompleted");

	Params::FortOutpostAnalytics_FireAnalyticsEvent_OutpostAttackWaveCompleted Parms{};

	Parms.SourceBp = SourceBp;
	Parms.BuildingType = std::move(BuildingType);
	Parms.NumMissionsCompleted = NumMissionsCompleted;
	Parms.Succeeded = Succeeded;
	Parms.Direction = std::move(Direction);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostAnalytics.FireAnalyticsEvent_OutpostBuildingActivated
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingType                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             NumMissionsCompleted                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOutpostAnalytics::FireAnalyticsEvent_OutpostBuildingActivated(const class UObject* SourceBp, const class FString& BuildingType, const int32 NumMissionsCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostAnalytics", "FireAnalyticsEvent_OutpostBuildingActivated");

	Params::FortOutpostAnalytics_FireAnalyticsEvent_OutpostBuildingActivated Parms{};

	Parms.SourceBp = SourceBp;
	Parms.BuildingType = std::move(BuildingType);
	Parms.NumMissionsCompleted = NumMissionsCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostAnalytics.FireAnalyticsEvent_OutpostBuildingDefended
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    BuildingType                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             NumMissionsCompleted                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOutpostAnalytics::FireAnalyticsEvent_OutpostBuildingDefended(const class UObject* SourceBp, const class FString& BuildingType, const int32 NumMissionsCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostAnalytics", "FireAnalyticsEvent_OutpostBuildingDefended");

	Params::FortOutpostAnalytics_FireAnalyticsEvent_OutpostBuildingDefended Parms{};

	Parms.SourceBp = SourceBp;
	Parms.BuildingType = std::move(BuildingType);
	Parms.NumMissionsCompleted = NumMissionsCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostAnalytics.FireAnalyticsEvent_OutpostSupplyDropPickedUp
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAnalyticsEventAttribute>&Resourcees                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortOutpostAnalytics::FireAnalyticsEvent_OutpostSupplyDropPickedUp(const class UObject* SourceBp, const TArray<struct FFortAnalyticsEventAttribute>& Resourcees)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostAnalytics", "FireAnalyticsEvent_OutpostSupplyDropPickedUp");

	Params::FortOutpostAnalytics_FireAnalyticsEvent_OutpostSupplyDropPickedUp Parms{};

	Parms.SourceBp = SourceBp;
	Parms.Resourcees = std::move(Resourcees);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOnboardingAnalytics.FireAnalyticsEvent_CinematicSkipped
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOnboardingAnalytics::FireAnalyticsEvent_CinematicSkipped(const class UObject* SourceBp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOnboardingAnalytics", "FireAnalyticsEvent_CinematicSkipped");

	Params::FortOnboardingAnalytics_FireAnalyticsEvent_CinematicSkipped Parms{};

	Parms.SourceBp = SourceBp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOnboardingAnalytics.FireAnalyticsEvent_VinderTipPlayed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    VinderTipTag                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortOnboardingAnalytics::FireAnalyticsEvent_VinderTipPlayed(const class UObject* SourceBp, const class FString& VinderTipTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOnboardingAnalytics", "FireAnalyticsEvent_VinderTipPlayed");

	Params::FortOnboardingAnalytics_FireAnalyticsEvent_VinderTipPlayed Parms{};

	Parms.SourceBp = SourceBp;
	Parms.VinderTipTag = std::move(VinderTipTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnalytics.ConstructAnalyticsAttribute
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    AttributeName                                          (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    StringValue                                            (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGuid&                     FGuidValue                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const int32                             IntValue                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             FloatValue                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              BoolValue                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FFortAnalyticsEventAttribute     ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortAnalyticsEventAttribute UFortAnalytics::ConstructAnalyticsAttribute(const class FString& AttributeName, const class FString& StringValue, const struct FGuid& FGuidValue, const int32 IntValue, const float FloatValue, const bool BoolValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAnalytics", "ConstructAnalyticsAttribute");

	Params::FortAnalytics_ConstructAnalyticsAttribute Parms{};

	Parms.AttributeName = std::move(AttributeName);
	Parms.StringValue = std::move(StringValue);
	Parms.FGuidValue = std::move(FGuidValue);
	Parms.IntValue = IntValue;
	Parms.FloatValue = FloatValue;
	Parms.BoolValue = BoolValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAnalytics.FireAnalyticsEvent_Blueprint
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAnalyticsEventAttribute&Attribute                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortAnalytics::FireAnalyticsEvent_Blueprint(const class UObject* SourceBp, const class FString& EventName, const struct FFortAnalyticsEventAttribute& Attribute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAnalytics", "FireAnalyticsEvent_Blueprint");

	Params::FortAnalytics_FireAnalyticsEvent_Blueprint Parms{};

	Parms.SourceBp = SourceBp;
	Parms.EventName = std::move(EventName);
	Parms.Attribute = std::move(Attribute);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnalytics.FireAnalyticsEvent_BlueprintArray
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAnalyticsEventAttribute>&Attributes                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortAnalytics::FireAnalyticsEvent_BlueprintArray(const class UObject* SourceBp, const class FString& EventName, const TArray<struct FFortAnalyticsEventAttribute>& Attributes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAnalytics", "FireAnalyticsEvent_BlueprintArray");

	Params::FortAnalytics_FireAnalyticsEvent_BlueprintArray Parms{};

	Parms.SourceBp = SourceBp;
	Parms.EventName = std::move(EventName);
	Parms.Attributes = std::move(Attributes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnalytics.FireMissionAnalyticsEvent_Blueprint
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortAnalyticsEventAttribute&Attribute                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortAnalytics::FireMissionAnalyticsEvent_Blueprint(const class UObject* SourceBp, const class FString& EventName, const struct FFortAnalyticsEventAttribute& Attribute)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAnalytics", "FireMissionAnalyticsEvent_Blueprint");

	Params::FortAnalytics_FireMissionAnalyticsEvent_Blueprint Parms{};

	Parms.SourceBp = SourceBp;
	Parms.EventName = std::move(EventName);
	Parms.Attribute = std::move(Attribute);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnalytics.FireMissionAnalyticsEvent_BlueprintArray
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class UObject*                    SourceBp                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    EventName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FFortAnalyticsEventAttribute>&Attributes                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UFortAnalytics::FireMissionAnalyticsEvent_BlueprintArray(const class UObject* SourceBp, const class FString& EventName, const TArray<struct FFortAnalyticsEventAttribute>& Attributes)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAnalytics", "FireMissionAnalyticsEvent_BlueprintArray");

	Params::FortAnalytics_FireMissionAnalyticsEvent_BlueprintArray Parms{};

	Parms.SourceBp = SourceBp;
	Parms.EventName = std::move(EventName);
	Parms.Attributes = std::move(Attributes);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnimInstance.AnimNotify_LeftFootStep
// (Final, Native, Public)
// Parameters:
// const class UAnimNotify*                Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAnimInstance::AnimNotify_LeftFootStep(const class UAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAnimInstance", "AnimNotify_LeftFootStep");

	Params::FortAnimInstance_AnimNotify_LeftFootStep Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnimInstance.AnimNotify_RightFootStep
// (Final, Native, Public)
// Parameters:
// const class UAnimNotify*                Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortAnimInstance::AnimNotify_RightFootStep(const class UAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAnimInstance", "AnimNotify_RightFootStep");

	Params::FortAnimInstance_AnimNotify_RightFootStep Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAnimInstance.TryGetFortAIPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortAIPawn*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIPawn* UFortAnimInstance::TryGetFortAIPawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAnimInstance", "TryGetFortAIPawn");

	Params::FortAnimInstance_TryGetFortAIPawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAnimInstance.TryGetFortPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPawn*                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPawn* UFortAnimInstance::TryGetFortPawn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAnimInstance", "TryGetFortPawn");

	Params::FortAnimInstance_TryGetFortPawn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerAnimGraphInstance.AnimNotify_PlayFireFX
// (Final, Native, Public)
// Parameters:
// const class UAnimNotify*                Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerAnimGraphInstance::AnimNotify_PlayFireFX(const class UAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAnimGraphInstance", "AnimNotify_PlayFireFX");

	Params::FortPlayerAnimGraphInstance_AnimNotify_PlayFireFX Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAnimGraphInstance.AnimNotify_PlaySecondaryFireFX
// (Final, Native, Public)
// Parameters:
// const class UAnimNotify*                Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerAnimGraphInstance::AnimNotify_PlaySecondaryFireFX(const class UAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAnimGraphInstance", "AnimNotify_PlaySecondaryFireFX");

	Params::FortPlayerAnimGraphInstance_AnimNotify_PlaySecondaryFireFX Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerAnimGraphInstance.AnimNotify_StopFireFX
// (Final, Native, Public)
// Parameters:
// const class UAnimNotify*                Notify                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPlayerAnimGraphInstance::AnimNotify_StopFireFX(const class UAnimNotify* Notify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerAnimGraphInstance", "AnimNotify_StopFireFX");

	Params::FortPlayerAnimGraphInstance_AnimNotify_StopFireFX Parms{};

	Parms.Notify = Notify;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAsyncAction_SendQuestStatEvent.SendClientStatEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UFortQuestManager*                QuestManager_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDataTableRowHandle&       ObjectiveStat_0                                        (Parm, NativeAccessSpecifierPublic)
// int32                                   Count_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAsyncAction_SendQuestStatEvent*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAsyncAction_SendQuestStatEvent* UFortAsyncAction_SendQuestStatEvent::SendClientStatEvent(class UFortQuestManager* QuestManager_0, const struct FDataTableRowHandle& ObjectiveStat_0, int32 Count_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAsyncAction_SendQuestStatEvent", "SendClientStatEvent");

	Params::FortAsyncAction_SendQuestStatEvent_SendClientStatEvent Parms{};

	Parms.QuestManager_0 = QuestManager_0;
	Parms.ObjectiveStat_0 = std::move(ObjectiveStat_0);
	Parms.Count_0 = Count_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAsyncAction_SendQuestStatEvent.SendClientStatEventWithTags
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UFortQuestManager*                QuestManager_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     TargetTags_0                                           (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     SourceTags_0                                           (Parm, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     ContextTags_0                                          (Parm, NativeAccessSpecifierPublic)
// int32                                   Count_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortAsyncAction_SendQuestStatEvent*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAsyncAction_SendQuestStatEvent* UFortAsyncAction_SendQuestStatEvent::SendClientStatEventWithTags(class UFortQuestManager* QuestManager_0, const struct FGameplayTagContainer& TargetTags_0, const struct FGameplayTagContainer& SourceTags_0, const struct FGameplayTagContainer& ContextTags_0, int32 Count_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortAsyncAction_SendQuestStatEvent", "SendClientStatEventWithTags");

	Params::FortAsyncAction_SendQuestStatEvent_SendClientStatEventWithTags Parms{};

	Parms.QuestManager_0 = QuestManager_0;
	Parms.TargetTags_0 = std::move(TargetTags_0);
	Parms.SourceTags_0 = std::move(SourceTags_0);
	Parms.ContextTags_0 = std::move(ContextTags_0);
	Parms.Count_0 = Count_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortBuildingTrapSet.OnRep_Durability
// (Final, Native, Public)

void UFortBuildingTrapSet::OnRep_Durability()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortBuildingTrapSet", "OnRep_Durability");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortHomebaseSet.OnRep_HomebaseAttr
// (Final, Native, Public)

void UFortHomebaseSet::OnRep_HomebaseAttr()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomebaseSet", "OnRep_HomebaseAttr");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMovementSet.OnRep_SpeedMultiplier
// (Final, Native, Public)

void UFortMovementSet::OnRep_SpeedMultiplier()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMovementSet", "OnRep_SpeedMultiplier");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortNotificationManager.OnRep_Notifications
// (Native, Protected)

void AFortNotificationManager::OnRep_Notifications()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortNotificationManager", "OnRep_Notifications");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyBeaconClient.ClientAllowedToProceedFromReservation
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPartyBeaconClient::ClientAllowedToProceedFromReservation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyBeaconClient", "ClientAllowedToProceedFromReservation");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyBeaconClient.ClientAllowedToProceedFromReservationTimeout
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPartyBeaconClient::ClientAllowedToProceedFromReservationTimeout()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyBeaconClient", "ClientAllowedToProceedFromReservationTimeout");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyBeaconClient.ClientReconnectResponse
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// EPartyReservationResult                 ReservationResponse                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPartyBeaconClient::ClientReconnectResponse(EPartyReservationResult ReservationResponse)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyBeaconClient", "ClientReconnectResponse");

	Params::FortPartyBeaconClient_ClientReconnectResponse Parms{};

	Parms.ReservationResponse = ReservationResponse;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyBeaconClient.ServerEmptyServerReservationRequest
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    InSessionId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FEmptyServerReservation&   ReservationData                                        (ConstParm, Parm, NativeAccessSpecifierPublic)
// const struct FPartyReservation&         Reservation                                            (Parm, NativeAccessSpecifierPublic)

void AFortPartyBeaconClient::ServerEmptyServerReservationRequest(const class FString& InSessionId, const struct FEmptyServerReservation& ReservationData, const struct FPartyReservation& Reservation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyBeaconClient", "ServerEmptyServerReservationRequest");

	Params::FortPartyBeaconClient_ServerEmptyServerReservationRequest Parms{};

	Parms.InSessionId = std::move(InSessionId);
	Parms.ReservationData = std::move(ReservationData);
	Parms.Reservation = std::move(Reservation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPartyBeaconClient.ServerReconnectExistingReservation
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    InSessionId                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FUniqueNetIdRepl&          RequestingPlayer                                       (Parm, NativeAccessSpecifierPublic)

void AFortPartyBeaconClient::ServerReconnectExistingReservation(const class FString& InSessionId, const struct FUniqueNetIdRepl& RequestingPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPartyBeaconClient", "ServerReconnectExistingReservation");

	Params::FortPartyBeaconClient_ServerReconnectExistingReservation Parms{};

	Parms.InSessionId = std::move(InSessionId);
	Parms.RequestingPlayer = std::move(RequestingPlayer);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConsumableItemDefinition.ConsumeItem
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayEventData&        EventData                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortConsumableItemDefinition::ConsumeItem(const struct FGameplayEventData& EventData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConsumableItemDefinition", "ConsumeItem");

	Params::FortConsumableItemDefinition_ConsumeItem Parms{};

	Parms.EventData = std::move(EventData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortConsumableItemDefinition.GetAnimPlayRate
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortConsumableItemDefinition::GetAnimPlayRate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConsumableItemDefinition", "GetAnimPlayRate");

	Params::FortConsumableItemDefinition_GetAnimPlayRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortConsumableItemDefinition.GetHealthRestored
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ItemLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortConsumableItemDefinition::GetHealthRestored(int32 ItemLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortConsumableItemDefinition", "GetHealthRestored");

	Params::FortConsumableItemDefinition_GetHealthRestored Parms{};

	Parms.ItemLevel = ItemLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterCamera.SetTileFocus
// (Event, Public, BlueprintEvent)
// Parameters:
// class AFortTheaterMapTile*              TargetTile                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTheaterCamera::SetTileFocus(class AFortTheaterMapTile* TargetTile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterCamera", "SetTileFocus");

	Params::FortTheaterCamera_SetTileFocus Parms{};

	Parms.TargetTile = TargetTile;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortTheaterCamera.LimitToTheater
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   DesiredPosition                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector AFortTheaterCamera::LimitToTheater(const struct FVector& DesiredPosition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterCamera", "LimitToTheater");

	Params::FortTheaterCamera_LimitToTheater Parms{};

	Parms.DesiredPosition = std::move(DesiredPosition);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvP.GetItemCollector
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ABuildingItemCollectorActor*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingItemCollectorActor* AFortGameStatePvP::GetItemCollector()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "GetItemCollector");

	Params::FortGameStatePvP_GetItemCollector Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvP.OnRep_ItemCollector
// (Final, Native, Public)

void AFortGameStatePvP::OnRep_ItemCollector()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "OnRep_ItemCollector");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.OnRep_MatchLevel
// (Final, Native, Private)

void AFortGameStatePvP::OnRep_MatchLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "OnRep_MatchLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.OnRep_RoundTimeRemaining
// (Native, Protected)

void AFortGameStatePvP::OnRep_RoundTimeRemaining()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "OnRep_RoundTimeRemaining");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.OnRep_StalemateTimeRemaining
// (Native, Protected)

void AFortGameStatePvP::OnRep_StalemateTimeRemaining()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "OnRep_StalemateTimeRemaining");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.SetGameDifficultyRow
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       GameDifficultyInfo                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortGameStatePvP::SetGameDifficultyRow(const struct FDataTableRowHandle& GameDifficultyInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "SetGameDifficultyRow");

	Params::FortGameStatePvP_SetGameDifficultyRow Parms{};

	Parms.GameDifficultyInfo = std::move(GameDifficultyInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.SetMatchLevel
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   InMatchLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortGameStatePvP::SetMatchLevel(int32 InMatchLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "SetMatchLevel");

	Params::FortGameStatePvP_SetMatchLevel Parms{};

	Parms.InMatchLevel = InMatchLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvP.GetAverageHomebaseRating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvP::GetAverageHomebaseRating() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "GetAverageHomebaseRating");

	Params::FortGameStatePvP_GetAverageHomebaseRating Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvP.GetMatchLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvP::GetMatchLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "GetMatchLevel");

	Params::FortGameStatePvP_GetMatchLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvP.GetRoundTimeAccumulated
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvP::GetRoundTimeAccumulated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "GetRoundTimeAccumulated");

	Params::FortGameStatePvP_GetRoundTimeAccumulated Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvP.GetTotalHomebaseRating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvP::GetTotalHomebaseRating() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvP", "GetTotalHomebaseRating");

	Params::FortGameStatePvP_GetTotalHomebaseRating Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortClientEventInterface.BlueprintCustomHandleClientEvent
// (BlueprintCosmetic, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// class UObject*                          EventSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortClientEvent&          ClientEvent                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void IFortClientEventInterface::BlueprintCustomHandleClientEvent(class UObject* EventSource, class UObject* EventFocus, const struct FFortClientEvent& ClientEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortClientEventInterface", "BlueprintCustomHandleClientEvent");

	Params::FortClientEventInterface_BlueprintCustomHandleClientEvent Parms{};

	Parms.EventSource = EventSource;
	Parms.EventFocus = EventFocus;
	Parms.ClientEvent = std::move(ClientEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortHomeTeleporterInterface.OnHomeTeleporterBound
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     OldHomeActor                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortHomeTeleporterInterface::OnHomeTeleporterBound(class AFortPlayerPawn* PlayerPawn, const class AActor* OldHomeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeTeleporterInterface", "OnHomeTeleporterBound");

	Params::FortHomeTeleporterInterface_OnHomeTeleporterBound Parms{};

	Parms.PlayerPawn = PlayerPawn;
	Parms.OldHomeActor = OldHomeActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortHomeTeleporterInterface.OnHomeTeleporterBoundServer
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     OldHomeActor                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortHomeTeleporterInterface::OnHomeTeleporterBoundServer(class AFortPlayerPawn* PlayerPawn, const class AActor* OldHomeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeTeleporterInterface", "OnHomeTeleporterBoundServer");

	Params::FortHomeTeleporterInterface_OnHomeTeleporterBoundServer Parms{};

	Parms.PlayerPawn = PlayerPawn;
	Parms.OldHomeActor = OldHomeActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortHomeTeleporterInterface.OnHomeTeleporterUnbound
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     NewHomeActor                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortHomeTeleporterInterface::OnHomeTeleporterUnbound(class AFortPlayerPawn* PlayerPawn, const class AActor* NewHomeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeTeleporterInterface", "OnHomeTeleporterUnbound");

	Params::FortHomeTeleporterInterface_OnHomeTeleporterUnbound Parms{};

	Parms.PlayerPawn = PlayerPawn;
	Parms.NewHomeActor = NewHomeActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortHomeTeleporterInterface.OnHomeTeleporterUnboundServer
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
// Parameters:
// class AFortPlayerPawn*                  PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     NewHomeActor                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortHomeTeleporterInterface::OnHomeTeleporterUnboundServer(class AFortPlayerPawn* PlayerPawn, const class AActor* NewHomeActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortHomeTeleporterInterface", "OnHomeTeleporterUnboundServer");

	Params::FortHomeTeleporterInterface_OnHomeTeleporterUnboundServer Parms{};

	Parms.PlayerPawn = PlayerPawn;
	Parms.NewHomeActor = NewHomeActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortTutorialNotification.HideTutorialScreen
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)

void AFortTutorialNotification::HideTutorialScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "HideTutorialScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.OnNotificationContinue
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTutorialNotification::OnNotificationContinue(class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo, class FName EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "OnNotificationContinue");

	Params::FortTutorialNotification_OnNotificationContinue Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.EventName = EventName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetButtonEnabled
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bButtonEnabled                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetButtonEnabled(bool bButtonEnabled, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetButtonEnabled");

	Params::FortTutorialNotification_SetButtonEnabled Parms{};

	Parms.bButtonEnabled = bButtonEnabled;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetHAlign
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// EHorizontalAlignment                    HAlign                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetHAlign(EHorizontalAlignment HAlign, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetHAlign");

	Params::FortTutorialNotification_SetHAlign Parms{};

	Parms.HAlign = HAlign;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetLightboxDisableInputOnly
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bLightboxDisableInputOnly                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetLightboxDisableInputOnly(bool bLightboxDisableInputOnly, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetLightboxDisableInputOnly");

	Params::FortTutorialNotification_SetLightboxDisableInputOnly Parms{};

	Parms.bLightboxDisableInputOnly = bLightboxDisableInputOnly;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetLightboxEnabled
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bLightboxEnabled                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetLightboxEnabled(bool bLightboxEnabled, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetLightboxEnabled");

	Params::FortTutorialNotification_SetLightboxEnabled Parms{};

	Parms.bLightboxEnabled = bLightboxEnabled;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetNameText
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// const class FText&                      NameText                                               (Parm, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetNameText(const class FText& NameText, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetNameText");

	Params::FortTutorialNotification_SetNameText Parms{};

	Parms.NameText = std::move(NameText);
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetPadding
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// const struct FMargin&                   Padding                                                (Parm, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetPadding(const struct FMargin& Padding, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetPadding");

	Params::FortTutorialNotification_SetPadding Parms{};

	Parms.Padding = std::move(Padding);
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetSystemText
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// const class FText&                      SystemText                                             (Parm, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetSystemText(const class FText& SystemText, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetSystemText");

	Params::FortTutorialNotification_SetSystemText Parms{};

	Parms.SystemText = std::move(SystemText);
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.SetVAlign
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// EVerticalAlignment                      VAlign                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTutorialNotification::SetVAlign(EVerticalAlignment VAlign, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "SetVAlign");

	Params::FortTutorialNotification_SetVAlign Parms{};

	Parms.VAlign = VAlign;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTutorialNotification.ShowTutorialScreen
// (Final, BlueprintCosmetic, Native, Protected, BlueprintCallable)
// Parameters:
// class UTexture2D*                       TutorialImage                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTutorialNotification::ShowTutorialScreen(class UTexture2D* TutorialImage)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTutorialNotification", "ShowTutorialScreen");

	Params::FortTutorialNotification_ShowTutorialScreen Parms{};

	Parms.TutorialImage = TutorialImage;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCinematicNotification.OnPlayerSkippedCutscene
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortCinematicNotification::OnPlayerSkippedCutscene()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCinematicNotification", "OnPlayerSkippedCutscene");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCombatManager.GetCombatFactorValue
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortCombatFactors                      CombatFactor                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortCombatManager::GetCombatFactorValue(EFortCombatFactors CombatFactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "GetCombatFactorValue");

	Params::FortCombatManager_GetCombatFactorValue Parms{};

	Parms.CombatFactor = CombatFactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCombatManager.GetCurrentMaxHeatPercent
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortCombatManager::GetCurrentMaxHeatPercent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "GetCurrentMaxHeatPercent");

	Params::FortCombatManager_GetCurrentMaxHeatPercent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCombatManager.GetEventHeatPercent
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortCombatEvents                       CombatEvent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortCombatManager::GetEventHeatPercent(EFortCombatEvents CombatEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "GetEventHeatPercent");

	Params::FortCombatManager_GetEventHeatPercent Parms{};

	Parms.CombatEvent = CombatEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCombatManager.GetEventHeatPercentTotal
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortCombatEvents                       CombatEvent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortCombatManager::GetEventHeatPercentTotal(EFortCombatEvents CombatEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "GetEventHeatPercentTotal");

	Params::FortCombatManager_GetEventHeatPercentTotal Parms{};

	Parms.CombatEvent = CombatEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortCombatManager.OnRep_CombatEventHeat
// (Final, Native, Public)

void AFortCombatManager::OnRep_CombatEventHeat()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "OnRep_CombatEventHeat");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCombatManager.OnThresholdChange
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortCombatThresholds                   OldThreshold                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortCombatThresholds                   NewThreshold                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCombatManager::OnThresholdChange(EFortCombatThresholds OldThreshold, EFortCombatThresholds NewThreshold)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCombatManager", "OnThresholdChange");

	Params::FortCombatManager_OnThresholdChange Parms{};

	Parms.OldThreshold = OldThreshold;
	Parms.NewThreshold = NewThreshold;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortAlterationItem.GetAlterationDefinitionBP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortAlterationItemDefinition*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortAlterationItemDefinition* UFortAlterationItem::GetAlterationDefinitionBP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAlterationItem", "GetAlterationDefinitionBP");

	Params::FortAlterationItem_GetAlterationDefinitionBP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDayNightLightingAndFog.BreakExponentialHeightFogValues
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FExponentialHeightFogValues&HeightFogValues                                        (Parm, NativeAccessSpecifierPublic)
// float*                                  FogDensity                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  FogHeightFalloff                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  FogMaxOpacity                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  StartDistance                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  DirectionalInscatteringExponent                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  DirectionalInscatteringStartDistance                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor*                    DirectionalInscatteringColor                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FLinearColor*                    FogInscatteringColor                                   (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::BreakExponentialHeightFogValues(const struct FExponentialHeightFogValues& HeightFogValues, float* FogDensity, float* FogHeightFalloff, float* FogMaxOpacity, float* StartDistance, float* DirectionalInscatteringExponent, float* DirectionalInscatteringStartDistance, struct FLinearColor* DirectionalInscatteringColor, struct FLinearColor* FogInscatteringColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortDayNightLightingAndFog", "BreakExponentialHeightFogValues");

	Params::FortDayNightLightingAndFog_BreakExponentialHeightFogValues Parms{};

	Parms.HeightFogValues = std::move(HeightFogValues);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (FogDensity != nullptr)
		*FogDensity = Parms.FogDensity;

	if (FogHeightFalloff != nullptr)
		*FogHeightFalloff = Parms.FogHeightFalloff;

	if (FogMaxOpacity != nullptr)
		*FogMaxOpacity = Parms.FogMaxOpacity;

	if (StartDistance != nullptr)
		*StartDistance = Parms.StartDistance;

	if (DirectionalInscatteringExponent != nullptr)
		*DirectionalInscatteringExponent = Parms.DirectionalInscatteringExponent;

	if (DirectionalInscatteringStartDistance != nullptr)
		*DirectionalInscatteringStartDistance = Parms.DirectionalInscatteringStartDistance;

	if (DirectionalInscatteringColor != nullptr)
		*DirectionalInscatteringColor = std::move(Parms.DirectionalInscatteringColor);

	if (FogInscatteringColor != nullptr)
		*FogInscatteringColor = std::move(Parms.FogInscatteringColor);
}


// Function FortniteGame.FortDayNightLightingAndFog.MakeExponentialHeightFogValues
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   FogDensity                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FogHeightFalloff                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FogMaxOpacity                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StartDistance                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DirectionalInscatteringExponent                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DirectionalInscatteringStartDistance                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              DirectionalInscatteringColor                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              FogInscatteringColor                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FExponentialHeightFogValues      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FExponentialHeightFogValues AFortDayNightLightingAndFog::MakeExponentialHeightFogValues(float FogDensity, float FogHeightFalloff, float FogMaxOpacity, float StartDistance, float DirectionalInscatteringExponent, float DirectionalInscatteringStartDistance, const struct FLinearColor& DirectionalInscatteringColor, const struct FLinearColor& FogInscatteringColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortDayNightLightingAndFog", "MakeExponentialHeightFogValues");

	Params::FortDayNightLightingAndFog_MakeExponentialHeightFogValues Parms{};

	Parms.FogDensity = FogDensity;
	Parms.FogHeightFalloff = FogHeightFalloff;
	Parms.FogMaxOpacity = FogMaxOpacity;
	Parms.StartDistance = StartDistance;
	Parms.DirectionalInscatteringExponent = DirectionalInscatteringExponent;
	Parms.DirectionalInscatteringStartDistance = DirectionalInscatteringStartDistance;
	Parms.DirectionalInscatteringColor = std::move(DirectionalInscatteringColor);
	Parms.FogInscatteringColor = std::move(FogInscatteringColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDayNightLightingAndFog.FFToTimeOfDay
// (Final, Exec, Native, Private)
// Parameters:
// float                                   FastForwardTime                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FastForwardSpeed                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::FFToTimeOfDay(float FastForwardTime, float FastForwardSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "FFToTimeOfDay");

	Params::FortDayNightLightingAndFog_FFToTimeOfDay Parms{};

	Parms.FastForwardTime = FastForwardTime;
	Parms.FastForwardSpeed = FastForwardSpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.GetPreviousDayPhase
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortDayPhase                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortDayPhase AFortDayNightLightingAndFog::GetPreviousDayPhase()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "GetPreviousDayPhase");

	Params::FortDayNightLightingAndFog_GetPreviousDayPhase Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDayNightLightingAndFog.OnDayPhaseChange
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortDayNightLightingAndFog::OnDayPhaseChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnDayPhaseChange");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortDayNightLightingAndFog.OnRep_HeightFogEnabled
// (Native, Public)

void AFortDayNightLightingAndFog::OnRep_HeightFogEnabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnRep_HeightFogEnabled");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.OnRep_TimeOfDay
// (Native, Public)

void AFortDayNightLightingAndFog::OnRep_TimeOfDay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnRep_TimeOfDay");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.OnRep_TimeOfDayInit
// (Native, Public)

void AFortDayNightLightingAndFog::OnRep_TimeOfDayInit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnRep_TimeOfDayInit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.OnStormEnd
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortDayNightLightingAndFog::OnStormEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnStormEnd");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortDayNightLightingAndFog.OnStormStart
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortDayNightLightingAndFog::OnStormStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnStormStart");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortDayNightLightingAndFog.OnUpdateDirectionalLightForTimeOfDay
// (BlueprintCosmetic, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FLinearColor&              AboutToApplyDirectionalLightColor                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::OnUpdateDirectionalLightForTimeOfDay(const struct FLinearColor& AboutToApplyDirectionalLightColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnUpdateDirectionalLightForTimeOfDay");

	Params::FortDayNightLightingAndFog_OnUpdateDirectionalLightForTimeOfDay Parms{};

	Parms.AboutToApplyDirectionalLightColor = std::move(AboutToApplyDirectionalLightColor);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortDayNightLightingAndFog.OnUpdateHeightFogForTimeOfDay
// (BlueprintCosmetic, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FExponentialHeightFogValues&AboutToApplyFogValues                                  (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::OnUpdateHeightFogForTimeOfDay(const struct FExponentialHeightFogValues& AboutToApplyFogValues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "OnUpdateHeightFogForTimeOfDay");

	Params::FortDayNightLightingAndFog_OnUpdateHeightFogForTimeOfDay Parms{};

	Parms.AboutToApplyFogValues = std::move(AboutToApplyFogValues);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortDayNightLightingAndFog.SetDayPhase
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    DayPhase                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetDayPhase(const class FString& DayPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetDayPhase");

	Params::FortDayNightLightingAndFog_SetDayPhase Parms{};

	Parms.DayPhase = std::move(DayPhase);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetDirectionalLightColorMultiplier
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewDirectionalLightColorMultiplier                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetDirectionalLightColorMultiplier(float NewDirectionalLightColorMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetDirectionalLightColorMultiplier");

	Params::FortDayNightLightingAndFog_SetDirectionalLightColorMultiplier Parms{};

	Parms.NewDirectionalLightColorMultiplier = NewDirectionalLightColorMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetFogDirectionalInscatteringMultiplier
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewFogDirectionalInscatteringMultiplier                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetFogDirectionalInscatteringMultiplier(float NewFogDirectionalInscatteringMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetFogDirectionalInscatteringMultiplier");

	Params::FortDayNightLightingAndFog_SetFogDirectionalInscatteringMultiplier Parms{};

	Parms.NewFogDirectionalInscatteringMultiplier = NewFogDirectionalInscatteringMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetLightningColorAlpha
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewLightningColorAlpha                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetLightningColorAlpha(float NewLightningColorAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetLightningColorAlpha");

	Params::FortDayNightLightingAndFog_SetLightningColorAlpha Parms{};

	Parms.NewLightningColorAlpha = NewLightningColorAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetStormStrength
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewStormStrength                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetStormStrength(float NewStormStrength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetStormStrength");

	Params::FortDayNightLightingAndFog_SetStormStrength Parms{};

	Parms.NewStormStrength = NewStormStrength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDay
// (Final, Exec, Native, Private)
// Parameters:
// const class FString&                    NewTimeOfDay                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDay(const class FString& NewTimeOfDay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDay");

	Params::FortDayNightLightingAndFog_SetTimeOfDay Parms{};

	Parms.NewTimeOfDay = std::move(NewTimeOfDay);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDayAbsoluteSpeed
// (Final, Exec, Native, Private)
// Parameters:
// float                                   NewTimeOfDaySpeed                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDayAbsoluteSpeed(float NewTimeOfDaySpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDayAbsoluteSpeed");

	Params::FortDayNightLightingAndFog_SetTimeOfDayAbsoluteSpeed Parms{};

	Parms.NewTimeOfDaySpeed = NewTimeOfDaySpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDayFloat
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   TimeOfDayInHours                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDayFloat(float TimeOfDayInHours)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDayFloat");

	Params::FortDayNightLightingAndFog_SetTimeOfDayFloat Parms{};

	Parms.TimeOfDayInHours = TimeOfDayInHours;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDayInHours
// (Final, Exec, Native, Private)
// Parameters:
// float                                   TimeOfDayInHours                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDayInHours(float TimeOfDayInHours)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDayInHours");

	Params::FortDayNightLightingAndFog_SetTimeOfDayInHours Parms{};

	Parms.TimeOfDayInHours = TimeOfDayInHours;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDaySpeed
// (Final, Exec, Native, Private)
// Parameters:
// float                                   TimeOfDaySpeedFactor                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDaySpeed(float TimeOfDaySpeedFactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDaySpeed");

	Params::FortDayNightLightingAndFog_SetTimeOfDaySpeed Parms{};

	Parms.TimeOfDaySpeedFactor = TimeOfDaySpeedFactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.SetTimeOfDaySpeedFloat
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InTimeOfDaySpeed                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDayNightLightingAndFog::SetTimeOfDaySpeedFloat(float InTimeOfDaySpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "SetTimeOfDaySpeedFloat");

	Params::FortDayNightLightingAndFog_SetTimeOfDaySpeedFloat Parms{};

	Parms.InTimeOfDaySpeed = InTimeOfDaySpeed;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.ToggleDebugForceStormEffects
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortDayNightLightingAndFog::ToggleDebugForceStormEffects()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "ToggleDebugForceStormEffects");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.ToggleSkipNight
// (Final, Exec, Native, Private)

void AFortDayNightLightingAndFog::ToggleSkipNight()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "ToggleSkipNight");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDayNightLightingAndFog.GetDayPhaseStartAnnouncementString
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString AFortDayNightLightingAndFog::GetDayPhaseStartAnnouncementString() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "GetDayPhaseStartAnnouncementString");

	Params::FortDayNightLightingAndFog_GetDayPhaseStartAnnouncementString Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDayNightLightingAndFog.GetStormStrength
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortDayNightLightingAndFog::GetStormStrength() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "GetStormStrength");

	Params::FortDayNightLightingAndFog_GetStormStrength Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDayNightLightingAndFog.GetThreatClouds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FThreatLocationInfo>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FThreatLocationInfo> AFortDayNightLightingAndFog::GetThreatClouds() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDayNightLightingAndFog", "GetThreatClouds");

	Params::FortDayNightLightingAndFog_GetThreatClouds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDecoPreview.CreatePreviewMID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInterface*               OverrideParentMaterial                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* AFortDecoPreview::CreatePreviewMID(class UMaterialInterface* OverrideParentMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "CreatePreviewMID");

	Params::FortDecoPreview_CreatePreviewMID Parms{};

	Parms.OverrideParentMaterial = OverrideParentMaterial;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDecoPreview.GetTextureParameterValueFromMeshComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*                   MeshComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ElementIdx                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ParamName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture* AFortDecoPreview::GetTextureParameterValueFromMeshComponent(class UMeshComponent* MeshComp, int32 ElementIdx, class FName ParamName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "GetTextureParameterValueFromMeshComponent");

	Params::FortDecoPreview_GetTextureParameterValueFromMeshComponent Parms{};

	Parms.MeshComp = MeshComp;
	Parms.ElementIdx = ElementIdx;
	Parms.ParamName = ParamName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortDecoPreview.OnBounceMotionUpdate
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   VectorScale                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDecoPreview::OnBounceMotionUpdate(float VectorScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "OnBounceMotionUpdate");

	Params::FortDecoPreview_OnBounceMotionUpdate Parms{};

	Parms.VectorScale = VectorScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.OnInitializeDecoPreview
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class ABuildingActor*             NewBuildingActor                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UFortDecoItemDefinition*    NewDecoItemDefinition                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDecoPreview::OnInitializeDecoPreview(const class ABuildingActor* NewBuildingActor, const class UFortDecoItemDefinition* NewDecoItemDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "OnInitializeDecoPreview");

	Params::FortDecoPreview_OnInitializeDecoPreview Parms{};

	Parms.NewBuildingActor = NewBuildingActor;
	Parms.NewDecoItemDefinition = NewDecoItemDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.OnUpdateScale
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// float                                   Scale                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InWorldSpacePivot                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortDecoPreview::OnUpdateScale(float Scale, const struct FVector& InWorldSpacePivot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "OnUpdateScale");

	Params::FortDecoPreview_OnUpdateScale Parms{};

	Parms.Scale = Scale;
	Parms.InWorldSpacePivot = std::move(InWorldSpacePivot);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.OnUpdateVisuals
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSafeToPlace                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortDecoPreview::OnUpdateVisuals(float DeltaSeconds, bool bSafeToPlace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "OnUpdateVisuals");

	Params::FortDecoPreview_OnUpdateVisuals Parms{};

	Parms.DeltaSeconds = DeltaSeconds;
	Parms.bSafeToPlace = bSafeToPlace;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.SetDiffuseTextureParameterOnMID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic*         Mid                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture*                         Texture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDecoPreview::SetDiffuseTextureParameterOnMID(class UMaterialInstanceDynamic* Mid, class UTexture* Texture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "SetDiffuseTextureParameterOnMID");

	Params::FortDecoPreview_SetDiffuseTextureParameterOnMID Parms{};

	Parms.Mid = Mid;
	Parms.Texture = Texture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.SetScalarParameterValueOnAllPreviewMIDs
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             ParamName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ParamValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortDecoPreview::SetScalarParameterValueOnAllPreviewMIDs(class FName ParamName, float ParamValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "SetScalarParameterValueOnAllPreviewMIDs");

	Params::FortDecoPreview_SetScalarParameterValueOnAllPreviewMIDs Parms{};

	Parms.ParamName = ParamName;
	Parms.ParamValue = ParamValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortDecoPreview.SetVectorParameterValueOnAllPreviewMIDs
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             ParamName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              ParamValue                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortDecoPreview::SetVectorParameterValueOnAllPreviewMIDs(class FName ParamName, const struct FLinearColor& ParamValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortDecoPreview", "SetVectorParameterValueOnAllPreviewMIDs");

	Params::FortDecoPreview_SetVectorParameterValueOnAllPreviewMIDs Parms{};

	Parms.ParamName = ParamName;
	Parms.ParamValue = std::move(ParamValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrackPreview.InitializeTrackPreview
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*             InTrackMeshComp1                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UStaticMeshComponent*             InTrackMeshComp2                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTrackPreview::InitializeTrackPreview(class UStaticMeshComponent* InTrackMeshComp1, class UStaticMeshComponent* InTrackMeshComp2)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackPreview", "InitializeTrackPreview");

	Params::FortTrackPreview_InitializeTrackPreview Parms{};

	Parms.InTrackMeshComp1 = InTrackMeshComp1;
	Parms.InTrackMeshComp2 = InTrackMeshComp2;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconState.OnRep_MissionGeneratorClassPath
// (Final, Native, Protected)

void AFortLobbyBeaconState::OnRep_MissionGeneratorClassPath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconState", "OnRep_MissionGeneratorClassPath");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconState.OnRep_MissionGeneratorDetailsRequirement
// (Final, Native, Protected)

void AFortLobbyBeaconState::OnRep_MissionGeneratorDetailsRequirement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconState", "OnRep_MissionGeneratorDetailsRequirement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ClientSay
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// const class FString&                    PlayerName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ClientSay(const class FString& PlayerName, const class FString& Message)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ClientSay");

	Params::FortLobbyBeaconClient_ClientSay Parms{};

	Parms.PlayerName = std::move(PlayerName);
	Parms.Message = std::move(Message);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerIncrementHomeBaseVersion
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerIncrementHomeBaseVersion(const struct FUniqueNetIdRepl& InUniqueId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerIncrementHomeBaseVersion");

	Params::FortLobbyBeaconClient_ServerIncrementHomeBaseVersion Parms{};

	Parms.InUniqueId = std::move(InUniqueId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSay
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSay(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSay");

	Params::FortLobbyBeaconClient_ServerSay Parms{};

	Parms.Msg = std::move(Msg);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSayTeam
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class FString&                    Msg                                                    (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSayTeam(const class FString& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSayTeam");

	Params::FortLobbyBeaconClient_ServerSayTeam Parms{};

	Parms.Msg = std::move(Msg);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetCharacterGender
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// EFortCustomGender                       GenderType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetCharacterGender(const struct FUniqueNetIdRepl& InUniqueId, EFortCustomGender GenderType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetCharacterGender");

	Params::FortLobbyBeaconClient_ServerSetCharacterGender Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.GenderType = GenderType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetCurrentCharacterXp
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const int32                             CurrentCharacterXp                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetCurrentCharacterXp(const struct FUniqueNetIdRepl& InUniqueId, const int32 CurrentCharacterXp)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetCurrentCharacterXp");

	Params::FortLobbyBeaconClient_ServerSetCurrentCharacterXp Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.CurrentCharacterXp = CurrentCharacterXp;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetGadget
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   INDEX                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    GadgetPersistentName                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetGadget(const struct FUniqueNetIdRepl& InUniqueId, int32 INDEX, const class FString& GadgetPersistentName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetGadget");

	Params::FortLobbyBeaconClient_ServerSetGadget Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.INDEX = INDEX;
	Parms.GadgetPersistentName = std::move(GadgetPersistentName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetHeroId
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class FString&                    InHeroId                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetHeroId(const struct FUniqueNetIdRepl& InUniqueId, const class FString& InHeroId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetHeroId");

	Params::FortLobbyBeaconClient_ServerSetHeroId Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.InHeroId = std::move(InHeroId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetHeroType
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortHeroType*              InHeroType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetHeroType(const struct FUniqueNetIdRepl& InUniqueId, const class UFortHeroType* InHeroType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetHeroType");

	Params::FortLobbyBeaconClient_ServerSetHeroType Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.InHeroType = InHeroType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconClient.ServerSetMatchmakingLevel
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const struct FUniqueNetIdRepl&          InUniqueId                                             (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)
// const int32                             MatchmakingLevel                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortLobbyBeaconClient::ServerSetMatchmakingLevel(const struct FUniqueNetIdRepl& InUniqueId, const int32 MatchmakingLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClient", "ServerSetMatchmakingLevel");

	Params::FortLobbyBeaconClient_ServerSetMatchmakingLevel Parms{};

	Parms.InUniqueId = std::move(InUniqueId);
	Parms.MatchmakingLevel = MatchmakingLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_CharacterGender
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_CharacterGender()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_CharacterGender");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_CharXP
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_CharXP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_CharXP");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_Gadgets
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_Gadgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_Gadgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_HeroID
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_HeroID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_HeroID");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_HeroType
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_HeroType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_HeroType");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_HomeBaseVersion
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_HomeBaseVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_HomeBaseVersion");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerState.OnRep_LobbyTimeRemaining
// (Native, Protected)

void AFortLobbyBeaconPlayerState::OnRep_LobbyTimeRemaining()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerState", "OnRep_LobbyTimeRemaining");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconPlayerStatePvP.OnRep_bReadiedUp
// (Final, Native, Protected)

void AFortLobbyBeaconPlayerStatePvP::OnRep_bReadiedUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconPlayerStatePvP", "OnRep_bReadiedUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlacementActorTagTest.LineTraceByChannel
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPlacementActor*              PlacementActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Start                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// ETraceTypeQuery                         TraceChannel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const TArray<class AActor*>&            ActorsToIgnore                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// struct FHitResult*                      OutHit                                                 (Parm, OutParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bIgnoreSelf                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPlacementActorTagTest::LineTraceByChannel(class AFortPlacementActor* PlacementActor, const struct FVector& Start, const struct FVector& End, ETraceTypeQuery TraceChannel, bool bTraceComplex, const TArray<class AActor*>& ActorsToIgnore, struct FHitResult* OutHit, bool bIgnoreSelf) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlacementActorTagTest", "LineTraceByChannel");

	Params::FortPlacementActorTagTest_LineTraceByChannel Parms{};

	Parms.PlacementActor = PlacementActor;
	Parms.Start = std::move(Start);
	Parms.End = std::move(End);
	Parms.TraceChannel = TraceChannel;
	Parms.bTraceComplex = bTraceComplex;
	Parms.ActorsToIgnore = std::move(ActorsToIgnore);
	Parms.bIgnoreSelf = bIgnoreSelf;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutHit != nullptr)
		*OutHit = std::move(Parms.OutHit);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlacementActorTagTest.ShouldApplyTagsToPlacementActor
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// class AFortPlacementActor*              FocusPlacementActor                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AveragePlacementActorLocation                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortPlacementActorTagTest::ShouldApplyTagsToPlacementActor(class AFortPlacementActor* FocusPlacementActor, const struct FVector& AveragePlacementActorLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlacementActorTagTest", "ShouldApplyTagsToPlacementActor");

	Params::FortPlacementActorTagTest_ShouldApplyTagsToPlacementActor Parms{};

	Parms.FocusPlacementActor = FocusPlacementActor;
	Parms.AveragePlacementActorLocation = std::move(AveragePlacementActorLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameSession.DumpReservations
// (Exec, Native, Public, Const)

void AFortGameSession::DumpReservations() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameSession", "DumpReservations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameModeFrontEnd.ShowPersonalizationScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            PC                                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortGameModeFrontEnd::ShowPersonalizationScreen(class AFortPlayerController* PC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameModeFrontEnd", "ShowPersonalizationScreen");

	Params::FortGameModeFrontEnd_ShowPersonalizationScreen Parms{};

	Parms.PC = PC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility_AIPortal.ModifyCollisions
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortGameplayAbility_AIPortal::ModifyCollisions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AIPortal", "ModifyCollisions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameplayAbility_AIPortal.GetPortalBuilding
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ABuildingSMActor*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingSMActor* UFortGameplayAbility_AIPortal::GetPortalBuilding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AIPortal", "GetPortalBuilding");

	Params::FortGameplayAbility_AIPortal_GetPortalBuilding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility_AIPortal.GetPortalInPoint
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortGameplayAbility_AIPortal::GetPortalInPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AIPortal", "GetPortalInPoint");

	Params::FortGameplayAbility_AIPortal_GetPortalInPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility_AIPortal.GetPortalOutPoint
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortGameplayAbility_AIPortal::GetPortalOutPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AIPortal", "GetPortalOutPoint");

	Params::FortGameplayAbility_AIPortal_GetPortalOutPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility_AIPortal.HasPortalOutPoint
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbility_AIPortal::HasPortalOutPoint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AIPortal", "HasPortalOutPoint");

	Params::FortGameplayAbility_AIPortal_HasPortalOutPoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbility_AITurnTransition.GetTurnTransitionMontageSectionNameAndYawRotationRate
// (Final, Native, Protected, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName*                            MontageSectionName                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  TurnYawRotationRate                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortGameplayAbility_AITurnTransition::GetTurnTransitionMontageSectionNameAndYawRotationRate(class FName* MontageSectionName, float* TurnYawRotationRate) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbility_AITurnTransition", "GetTurnTransitionMontageSectionNameAndYawRotationRate");

	Params::FortGameplayAbility_AITurnTransition_GetTurnTransitionMontageSectionNameAndYawRotationRate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (MontageSectionName != nullptr)
		*MontageSectionName = Parms.MontageSectionName;

	if (TurnYawRotationRate != nullptr)
		*TurnYawRotationRate = Parms.TurnYawRotationRate;
}


// Function FortniteGame.FortGameStateKeep.OnRep_PermaniteBoundariesInfo
// (Final, Native, Public)

void AFortGameStateKeep::OnRep_PermaniteBoundariesInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStateKeep", "OnRep_PermaniteBoundariesInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortGameStatePvPBaseDestruction.GetExperienceRequiredForTeamLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   TeamLevel                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvPBaseDestruction::GetExperienceRequiredForTeamLevel(int32 TeamLevel) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvPBaseDestruction", "GetExperienceRequiredForTeamLevel");

	Params::FortGameStatePvPBaseDestruction_GetExperienceRequiredForTeamLevel Parms{};

	Parms.TeamLevel = TeamLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvPBaseDestruction.GetMaxTeamExperience
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvPBaseDestruction::GetMaxTeamExperience() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvPBaseDestruction", "GetMaxTeamExperience");

	Params::FortGameStatePvPBaseDestruction_GetMaxTeamExperience Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvPBaseDestruction.GetMaxTeamLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvPBaseDestruction::GetMaxTeamLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvPBaseDestruction", "GetMaxTeamLevel");

	Params::FortGameStatePvPBaseDestruction_GetMaxTeamLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameStatePvPBaseDestruction.GetTeamLevelForExperienceAmount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   Experience                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortGameStatePvPBaseDestruction::GetTeamLevelForExperienceAmount(int32 Experience) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameStatePvPBaseDestruction", "GetTeamLevelForExperienceAmount");

	Params::FortGameStatePvPBaseDestruction_GetTeamLevelForExperienceAmount Parms{};

	Parms.Experience = Experience;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostItemDefinition.GetLongDescription
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortOutpostItemDefinition::GetLongDescription() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortOutpostItemDefinition", "GetLongDescription");

	Params::FortOutpostItemDefinition_GetLongDescription Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.ApplyGlobalEnvironmentDamageToActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           DamageTargetActor                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   EnvironmentDamage                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     AdditionalContextTags                                  (Parm, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayEffect>      EnvironmentDamageGE                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::ApplyGlobalEnvironmentDamageToActor(class AActor* DamageTargetActor, float EnvironmentDamage, const struct FGameplayTagContainer& AdditionalContextTags, TSubclassOf<class UGameplayEffect> EnvironmentDamageGE)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ApplyGlobalEnvironmentDamageToActor");

	Params::FortKismetLibrary_ApplyGlobalEnvironmentDamageToActor Parms{};

	Parms.DamageTargetActor = DamageTargetActor;
	Parms.EnvironmentDamage = EnvironmentDamage;
	Parms.AdditionalContextTags = std::move(AdditionalContextTags);
	Parms.EnvironmentDamageGE = EnvironmentDamageGE;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.ApplyGlobalEnvironmentGameplayEffectToActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           EffectTargetActor                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayEffect>      GameplayEffect                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GameplayEffectLevel                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     AdditionalContextTags                                  (Parm, NativeAccessSpecifierPublic)
// struct FActiveGameplayEffectHandle      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FActiveGameplayEffectHandle UFortKismetLibrary::ApplyGlobalEnvironmentGameplayEffectToActor(class AActor* EffectTargetActor, TSubclassOf<class UGameplayEffect> GameplayEffect, int32 GameplayEffectLevel, const struct FGameplayTagContainer& AdditionalContextTags)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ApplyGlobalEnvironmentGameplayEffectToActor");

	Params::FortKismetLibrary_ApplyGlobalEnvironmentGameplayEffectToActor Parms{};

	Parms.EffectTargetActor = EffectTargetActor;
	Parms.GameplayEffect = GameplayEffect;
	Parms.GameplayEffectLevel = GameplayEffectLevel;
	Parms.AdditionalContextTags = std::move(AdditionalContextTags);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.BroadcastMessage
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Message                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::BroadcastMessage(class UObject* WorldContextObject, const class FString& Message, class FName Type, class AActor* Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "BroadcastMessage");

	Params::FortKismetLibrary_BroadcastMessage Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Message = std::move(Message);
	Parms.Type = Type;
	Parms.Source = Source;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.BroadcastSound
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USoundBase*                       InSound                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   VolumeMultiplier                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PitchMultiplier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::BroadcastSound(class UObject* WorldContextObject, class USoundBase* InSound, float VolumeMultiplier, float PitchMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "BroadcastSound");

	Params::FortKismetLibrary_BroadcastSound Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InSound = InSound;
	Parms.VolumeMultiplier = VolumeMultiplier;
	Parms.PitchMultiplier = PitchMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.BroadcastSoundAtLocation
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USoundBase*                       InSound                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   VolumeMultiplier                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PitchMultiplier                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::BroadcastSoundAtLocation(class UObject* WorldContextObject, class USoundBase* InSound, const struct FVector& Location, float VolumeMultiplier, float PitchMultiplier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "BroadcastSoundAtLocation");

	Params::FortKismetLibrary_BroadcastSoundAtLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InSound = InSound;
	Parms.Location = std::move(Location);
	Parms.VolumeMultiplier = VolumeMultiplier;
	Parms.PitchMultiplier = PitchMultiplier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.ClearTutorialHighlights
// (Final, Native, Static, Public, BlueprintCallable)

void UFortKismetLibrary::ClearTutorialHighlights()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ClearTutorialHighlights");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.ClientRequestSetTimeOfDay
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeOfDay                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::ClientRequestSetTimeOfDay(class AFortPlayerController* FortPC, float TimeOfDay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ClientRequestSetTimeOfDay");

	Params::FortKismetLibrary_ClientRequestSetTimeOfDay Parms{};

	Parms.FortPC = FortPC;
	Parms.TimeOfDay = TimeOfDay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.ConvertToGameTime
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InRealTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::ConvertToGameTime(class UObject* WorldContextObject, float InRealTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ConvertToGameTime");

	Params::FortKismetLibrary_ConvertToGameTime Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRealTime = InRealTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.ConvertToRealTime
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InGameTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::ConvertToRealTime(class UObject* WorldContextObject, float InGameTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ConvertToRealTime");

	Params::FortKismetLibrary_ConvertToRealTime Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InGameTime = InGameTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.CreateNewSplineObject
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Outer_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortSpline*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortSpline* UFortKismetLibrary::CreateNewSplineObject(class UObject* Outer_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "CreateNewSplineObject");

	Params::FortKismetLibrary_CreateNewSplineObject Parms{};

	Parms.Outer_0 = Outer_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.DisableTutorialHighlight
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::DisableTutorialHighlight(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "DisableTutorialHighlight");

	Params::FortKismetLibrary_DisableTutorialHighlight Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.EnableTutorialHighlight
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::EnableTutorialHighlight(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "EnableTutorialHighlight");

	Params::FortKismetLibrary_EnableTutorialHighlight Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.EquipFortAbilitySet
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// TScriptInterface<class IAbilitySystemInterface>AbilitySystemInterfaceActor                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
// class UFortAbilitySet*                  AbilitySet                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          OverrideSourceObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortAbilitySetHandle            ReturnValue                                            (Parm, OutParm, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

struct FFortAbilitySetHandle UFortKismetLibrary::EquipFortAbilitySet(TScriptInterface<class IAbilitySystemInterface> AbilitySystemInterfaceActor, class UFortAbilitySet* AbilitySet, class UObject* OverrideSourceObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "EquipFortAbilitySet");

	Params::FortKismetLibrary_EquipFortAbilitySet Parms{};

	Parms.AbilitySystemInterfaceActor = AbilitySystemInterfaceActor;
	Parms.AbilitySet = AbilitySet;
	Parms.OverrideSourceObject = OverrideSourceObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.EvaluateCurveTableRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FCurveTableRowHandle&      CurveTableRowHandle                                    (Parm, NativeAccessSpecifierPublic)
// float                                   InXY                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutXY                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ContextString                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::EvaluateCurveTableRow(const struct FCurveTableRowHandle& CurveTableRowHandle, float InXY, float* OutXY, const class FString& ContextString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "EvaluateCurveTableRow");

	Params::FortKismetLibrary_EvaluateCurveTableRow Parms{};

	Parms.CurveTableRowHandle = std::move(CurveTableRowHandle);
	Parms.InXY = InXY;
	Parms.ContextString = std::move(ContextString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutXY != nullptr)
		*OutXY = Parms.OutXY;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.ExecuteClientEvent
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortClientEventName&      EventType                                              (Parm, NativeAccessSpecifierPublic)
// class UObject*                          EventSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::ExecuteClientEvent(class UObject* WorldContextObject, const struct FFortClientEventName& EventType, class UObject* EventSource, class UObject* EventFocus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ExecuteClientEvent");

	Params::FortKismetLibrary_ExecuteClientEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventType = std::move(EventType);
	Parms.EventSource = EventSource;
	Parms.EventFocus = EventFocus;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.GetActorTeam
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortTeam UFortKismetLibrary::GetActorTeam(const class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetActorTeam");

	Params::FortKismetLibrary_GetActorTeam Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetActorTeamInfo
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortTeamInfo*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortTeamInfo* UFortKismetLibrary::GetActorTeamInfo(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetActorTeamInfo");

	Params::FortKismetLibrary_GetActorTeamInfo Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetAIDirector
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortAIDirector*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIDirector* UFortKismetLibrary::GetAIDirector(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetAIDirector");

	Params::FortKismetLibrary_GetAIDirector Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetAIGoalManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortAIGoalManager*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAIGoalManager* UFortKismetLibrary::GetAIGoalManager(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetAIGoalManager");

	Params::FortKismetLibrary_GetAIGoalManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetAllFortPlayerControllers
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AFortPlayerController*>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AFortPlayerController*> UFortKismetLibrary::GetAllFortPlayerControllers(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetAllFortPlayerControllers");

	Params::FortKismetLibrary_GetAllFortPlayerControllers Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetAllFortPlayerPawns
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AFortPlayerPawn*>*         OutFortPlayerPawns                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::GetAllFortPlayerPawns(class UObject* WorldContextObject, TArray<class AFortPlayerPawn*>* OutFortPlayerPawns)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetAllFortPlayerPawns");

	Params::FortKismetLibrary_GetAllFortPlayerPawns Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutFortPlayerPawns != nullptr)
		*OutFortPlayerPawns = std::move(Parms.OutFortPlayerPawns);
}


// Function FortniteGame.FortKismetLibrary.GetBuildingHealthPercentage
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class ABuildingActor*             BuildingActor                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetBuildingHealthPercentage(const class ABuildingActor* BuildingActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetBuildingHealthPercentage");

	Params::FortKismetLibrary_GetBuildingHealthPercentage Parms{};

	Parms.BuildingActor = BuildingActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetBuildingStructuralSupportSystem
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBuildingStructuralSupportSystem**BuildingStructuralSupportSystem                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::GetBuildingStructuralSupportSystem(class UObject* WorldContextObject, class UBuildingStructuralSupportSystem** BuildingStructuralSupportSystem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetBuildingStructuralSupportSystem");

	Params::FortKismetLibrary_GetBuildingStructuralSupportSystem Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (BuildingStructuralSupportSystem != nullptr)
		*BuildingStructuralSupportSystem = Parms.BuildingStructuralSupportSystem;
}


// Function FortniteGame.FortKismetLibrary.GetCalculatedGameDifficulty
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetCalculatedGameDifficulty(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetCalculatedGameDifficulty");

	Params::FortKismetLibrary_GetCalculatedGameDifficulty Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetClosestBuildingActorFromArray
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     Actor                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class ABuildingSMActor*>&  ArrayOfBuildings                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class ABuildingSMActor*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingSMActor* UFortKismetLibrary::GetClosestBuildingActorFromArray(const class AActor* Actor, const TArray<class ABuildingSMActor*>& ArrayOfBuildings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetClosestBuildingActorFromArray");

	Params::FortKismetLibrary_GetClosestBuildingActorFromArray Parms{};

	Parms.Actor = Actor;
	Parms.ArrayOfBuildings = std::move(ArrayOfBuildings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetClosestFortPlayerPawn
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPlayerPawn*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerPawn* UFortKismetLibrary::GetClosestFortPlayerPawn(class UObject* WorldContextObject, const struct FVector& Position)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetClosestFortPlayerPawn");

	Params::FortKismetLibrary_GetClosestFortPlayerPawn Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Position = std::move(Position);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetCurrentDayPhase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortDayPhase UFortKismetLibrary::GetCurrentDayPhase(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetCurrentDayPhase");

	Params::FortKismetLibrary_GetCurrentDayPhase Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetDayNightDirectionalLightColor
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FLinearColor UFortKismetLibrary::GetDayNightDirectionalLightColor(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetDayNightDirectionalLightColor");

	Params::FortKismetLibrary_GetDayNightDirectionalLightColor Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetDayNightDirectionalLightVector
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortKismetLibrary::GetDayNightDirectionalLightVector(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetDayNightDirectionalLightVector");

	Params::FortKismetLibrary_GetDayNightDirectionalLightVector Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetDefaultAbsoluteTimeOfDaySpeed
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetDefaultAbsoluteTimeOfDaySpeed(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetDefaultAbsoluteTimeOfDaySpeed");

	Params::FortKismetLibrary_GetDefaultAbsoluteTimeOfDaySpeed Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetDirectionActorToActor
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           SourceActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UFortKismetLibrary::GetDirectionActorToActor(class AActor* SourceActor, class AActor* TargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetDirectionActorToActor");

	Params::FortKismetLibrary_GetDirectionActorToActor Parms{};

	Parms.SourceActor = SourceActor;
	Parms.TargetActor = TargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetFloatHoursUntilDayPhase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           DayPhase                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetFloatHoursUntilDayPhase(class UObject* WorldContextObject, EFortDayPhase DayPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetFloatHoursUntilDayPhase");

	Params::FortKismetLibrary_GetFloatHoursUntilDayPhase Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DayPhase = DayPhase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetFortPhysicalSurface
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// EPhysicalSurface                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhysicalSurface UFortKismetLibrary::GetFortPhysicalSurface(const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetFortPhysicalSurface");

	Params::FortKismetLibrary_GetFortPhysicalSurface Parms{};

	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetFortPlayerPawns
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AFortPlayerPawn*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AFortPlayerPawn*> UFortKismetLibrary::GetFortPlayerPawns(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetFortPlayerPawns");

	Params::FortKismetLibrary_GetFortPlayerPawns Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetGameDifficulty
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetGameDifficulty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetGameDifficulty");

	Params::FortKismetLibrary_GetGameDifficulty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetHostilityPercentage
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetHostilityPercentage(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetHostilityPercentage");

	Params::FortKismetLibrary_GetHostilityPercentage Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetHoursUntilDayPhase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           DayPhase                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortKismetLibrary::GetHoursUntilDayPhase(class UObject* WorldContextObject, EFortDayPhase DayPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetHoursUntilDayPhase");

	Params::FortKismetLibrary_GetHoursUntilDayPhase Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DayPhase = DayPhase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetHumanReadableName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UFortKismetLibrary::GetHumanReadableName(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetHumanReadableName");

	Params::FortKismetLibrary_GetHumanReadableName Parms{};

	Parms.Actor = Actor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetImpulseData
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)
// struct FVector*                         ImpulseDirection                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float*                                  KnockbackMagnitude                                     (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  KnockbackZAngle                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::GetImpulseData(const struct FGameplayEffectContextHandle& EffectContext, struct FVector* ImpulseDirection, float* KnockbackMagnitude, float* KnockbackZAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetImpulseData");

	Params::FortKismetLibrary_GetImpulseData Parms{};

	Parms.EffectContext = std::move(EffectContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ImpulseDirection != nullptr)
		*ImpulseDirection = std::move(Parms.ImpulseDirection);

	if (KnockbackMagnitude != nullptr)
		*KnockbackMagnitude = Parms.KnockbackMagnitude;

	if (KnockbackZAngle != nullptr)
		*KnockbackZAngle = Parms.KnockbackZAngle;
}


// Function FortniteGame.FortKismetLibrary.GetLocalFortPlayerControllers
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AFortPlayerController*>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AFortPlayerController*> UFortKismetLibrary::GetLocalFortPlayerControllers(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetLocalFortPlayerControllers");

	Params::FortKismetLibrary_GetLocalFortPlayerControllers Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetMeleeWeaponStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortMeleeWeaponStats*           OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetMeleeWeaponStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortMeleeWeaponStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetMeleeWeaponStatsRow");

	Params::FortKismetLibrary_GetMeleeWeaponStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetMIDForSkeletalMeshComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*           SkeletalMeshComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ElementIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstanceDynamic*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstanceDynamic* UFortKismetLibrary::GetMIDForSkeletalMeshComponent(class USkeletalMeshComponent* SkeletalMeshComponent, int32 ElementIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetMIDForSkeletalMeshComponent");

	Params::FortKismetLibrary_GetMIDForSkeletalMeshComponent Parms{};

	Parms.SkeletalMeshComponent = SkeletalMeshComponent;
	Parms.ElementIndex = ElementIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetNumericCVar
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    CVar                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutValue                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetNumericCVar(const class FString& CVar, float* OutValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetNumericCVar");

	Params::FortKismetLibrary_GetNumericCVar Parms{};

	Parms.CVar = std::move(CVar);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutValue != nullptr)
		*OutValue = Parms.OutValue;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetPawnStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortPawnStats*                  OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetPawnStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortPawnStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetPawnStatsRow");

	Params::FortKismetLibrary_GetPawnStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetPreviousDayPhase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortDayPhase UFortKismetLibrary::GetPreviousDayPhase(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetPreviousDayPhase");

	Params::FortKismetLibrary_GetPreviousDayPhase Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetPrimaryInstance
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayAbilitySpec&      Spec                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayAbility* UFortKismetLibrary::GetPrimaryInstance(const struct FGameplayAbilitySpec& Spec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetPrimaryInstance");

	Params::FortKismetLibrary_GetPrimaryInstance Parms{};

	Parms.Spec = std::move(Spec);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetRangedWeaponStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortRangedWeaponStats*          OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetRangedWeaponStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortRangedWeaponStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetRangedWeaponStatsRow");

	Params::FortKismetLibrary_GetRangedWeaponStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTeamAffiliation
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     ActorA                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     ActorB                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeamAffiliation                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortTeamAffiliation UFortKismetLibrary::GetTeamAffiliation(const class AActor* ActorA, const class AActor* ActorB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTeamAffiliation");

	Params::FortKismetLibrary_GetTeamAffiliation Parms{};

	Parms.ActorA = ActorA;
	Parms.ActorB = ActorB;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTeamAffiliationBetweenTeams
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortTeam                               TeamA                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               TeamB                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeamAffiliation                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortTeamAffiliation UFortKismetLibrary::GetTeamAffiliationBetweenTeams(EFortTeam TeamA, EFortTeam TeamB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTeamAffiliationBetweenTeams");

	Params::FortKismetLibrary_GetTeamAffiliationBetweenTeams Parms{};

	Parms.TeamA = TeamA;
	Parms.TeamB = TeamB;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTeamInfo
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortTeamInfo*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortTeamInfo* UFortKismetLibrary::GetTeamInfo(class UObject* WorldContextObject, EFortTeam Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTeamInfo");

	Params::FortKismetLibrary_GetTeamInfo Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetThreatVisualsManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortThreatVisualsManager*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortThreatVisualsManager* UFortKismetLibrary::GetThreatVisualsManager(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetThreatVisualsManager");

	Params::FortKismetLibrary_GetThreatVisualsManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTimeDayPhaseBegins
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           DayPhase                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetTimeDayPhaseBegins(class UObject* WorldContextObject, EFortDayPhase DayPhase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTimeDayPhaseBegins");

	Params::FortKismetLibrary_GetTimeDayPhaseBegins Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.DayPhase = DayPhase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTimeOfDay
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetTimeOfDay(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTimeOfDay");

	Params::FortKismetLibrary_GetTimeOfDay Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTimeOfDayAccumulator
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetTimeOfDayAccumulator(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTimeOfDayAccumulator");

	Params::FortKismetLibrary_GetTimeOfDayAccumulator Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTimeOfDaySpeed
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetTimeOfDaySpeed(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTimeOfDaySpeed");

	Params::FortKismetLibrary_GetTimeOfDaySpeed Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTimeUntilInRealTimeSeconds
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GameTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortKismetLibrary::GetTimeUntilInRealTimeSeconds(class UObject* WorldContextObject, float GameTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTimeUntilInRealTimeSeconds");

	Params::FortKismetLibrary_GetTimeUntilInRealTimeSeconds Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GameTime = GameTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipDescription
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            Description                                            (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipDescription(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* Description)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipDescription");

	Params::FortKismetLibrary_GetTooltipDescription Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Description != nullptr)
		*Description = std::move(Parms.Description);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipDescriptionArray
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FGameplayTag>&      Tags                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FText>*                    Descriptions                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipDescriptionArray(const class UObject* ObjectToDescribe, const TArray<struct FGameplayTag>& Tags, const class UFortTooltipContext* Context, TArray<class FText>* Descriptions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipDescriptionArray");

	Params::FortKismetLibrary_GetTooltipDescriptionArray Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tags = std::move(Tags);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Descriptions != nullptr)
		*Descriptions = std::move(Parms.Descriptions);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipDescriptionArrayFromTooltipClass
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortTooltip>         TooltipClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FGameplayTag>&      Tags                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FText>*                    Descriptions                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipDescriptionArrayFromTooltipClass(const class UObject* ObjectToDescribe, TSubclassOf<class UFortTooltip> TooltipClass, const TArray<struct FGameplayTag>& Tags, const class UFortTooltipContext* Context, TArray<class FText>* Descriptions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipDescriptionArrayFromTooltipClass");

	Params::FortKismetLibrary_GetTooltipDescriptionArrayFromTooltipClass Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.TooltipClass = TooltipClass;
	Parms.Tags = std::move(Tags);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Descriptions != nullptr)
		*Descriptions = std::move(Parms.Descriptions);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipDescriptionFromTooltipClass
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortTooltip>         TooltipClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            Description                                            (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipDescriptionFromTooltipClass(const class UObject* ObjectToDescribe, TSubclassOf<class UFortTooltip> TooltipClass, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* Description)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipDescriptionFromTooltipClass");

	Params::FortKismetLibrary_GetTooltipDescriptionFromTooltipClass Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.TooltipClass = TooltipClass;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Description != nullptr)
		*Description = std::move(Parms.Description);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipNumericValue
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Token                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipNumericValue(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FName Token, float* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipNumericValue");

	Params::FortKismetLibrary_GetTooltipNumericValue Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipNumericValueFromTooltipClass
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortTooltip>         TooltipClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (Parm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             Token                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Value                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipNumericValueFromTooltipClass(const class UObject* ObjectToDescribe, TSubclassOf<class UFortTooltip> TooltipClass, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FName Token, float* Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipNumericValueFromTooltipClass");

	Params::FortKismetLibrary_GetTooltipNumericValueFromTooltipClass Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.TooltipClass = TooltipClass;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Value != nullptr)
		*Value = Parms.Value;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipTextFromToken
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipTextFromToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipTextFromToken");

	Params::FortKismetLibrary_GetTooltipTextFromToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTooltipTextFromTokenFromTooltipClass
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UFortTooltip>         TooltipClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTooltipTextFromTokenFromTooltipClass(const class UObject* ObjectToDescribe, TSubclassOf<class UFortTooltip> TooltipClass, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTooltipTextFromTokenFromTooltipClass");

	Params::FortKismetLibrary_GetTooltipTextFromTokenFromTooltipClass Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.TooltipClass = TooltipClass;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetTrapStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortTrapStats*                  OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetTrapStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortTrapStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetTrapStatsRow");

	Params::FortKismetLibrary_GetTrapStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetWeaponDurabilityByRarityStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortWeaponDurabilityByRarityStats*OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetWeaponDurabilityByRarityStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortWeaponDurabilityByRarityStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetWeaponDurabilityByRarityStatsRow");

	Params::FortKismetLibrary_GetWeaponDurabilityByRarityStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.GetWeaponStatsRow
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDataTableRowHandle&       DataTableRowHandle                                     (Parm, NativeAccessSpecifierPublic)
// struct FFortBaseWeaponStats*            OutRow                                                 (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::GetWeaponStatsRow(const struct FDataTableRowHandle& DataTableRowHandle, struct FFortBaseWeaponStats* OutRow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "GetWeaponStatsRow");

	Params::FortKismetLibrary_GetWeaponStatsRow Parms{};

	Parms.DataTableRowHandle = std::move(DataTableRowHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutRow != nullptr)
		*OutRow = std::move(Parms.OutRow);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.HideTutorialWidget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::HideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "HideTutorialWidget");

	Params::FortKismetLibrary_HideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.IsCriticalHit
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::IsCriticalHit(const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "IsCriticalHit");

	Params::FortKismetLibrary_IsCriticalHit Parms{};

	Parms.EffectContext = std::move(EffectContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.IsFatalHit
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::IsFatalHit(const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "IsFatalHit");

	Params::FortKismetLibrary_IsFatalHit Parms{};

	Parms.EffectContext = std::move(EffectContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.IsFullBodyHit
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FGameplayEffectContextHandle&EffectContext                                          (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::IsFullBodyHit(const struct FGameplayEffectContextHandle& EffectContext)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "IsFullBodyHit");

	Params::FortKismetLibrary_IsFullBodyHit Parms{};

	Parms.EffectContext = std::move(EffectContext);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.IsValid
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAttributeInfo&            AttributeInfo                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::IsValid(const struct FAttributeInfo& AttributeInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "IsValid");

	Params::FortKismetLibrary_IsValid Parms{};

	Parms.AttributeInfo = std::move(AttributeInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.JonLHack_GetAllObjectsOfClassFromPath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Path                                                   (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UClass*                           Class_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UObject*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UObject*> UFortKismetLibrary::JonLHack_GetAllObjectsOfClassFromPath(const class FString& Path, class UClass* Class_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "JonLHack_GetAllObjectsOfClassFromPath");

	Params::FortKismetLibrary_JonLHack_GetAllObjectsOfClassFromPath Parms{};

	Parms.Path = std::move(Path);
	Parms.Class_0 = Class_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.K2_DoesPlayerHaveItem
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortItemDefinition*              ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortKismetLibrary::K2_DoesPlayerHaveItem(class AFortPlayerController* PlayerController, class UFortItemDefinition* ItemDefinition)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_DoesPlayerHaveItem");

	Params::FortKismetLibrary_K2_DoesPlayerHaveItem Parms{};

	Parms.PlayerController = PlayerController;
	Parms.ItemDefinition = ItemDefinition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.K2_GetClosestAxisXY
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   InVector                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortKismetLibrary::K2_GetClosestAxisXY(const struct FVector& InVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_GetClosestAxisXY");

	Params::FortKismetLibrary_K2_GetClosestAxisXY Parms{};

	Parms.InVector = std::move(InVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.K2_GiveItemToAllPlayers
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberToGive                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNotifyPlayer                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::K2_GiveItemToAllPlayers(class UObject* WorldContextObject, class UFortWorldItemDefinition* ItemDefinition, int32 NumberToGive, bool bNotifyPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_GiveItemToAllPlayers");

	Params::FortKismetLibrary_K2_GiveItemToAllPlayers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ItemDefinition = ItemDefinition;
	Parms.NumberToGive = NumberToGive;
	Parms.bNotifyPlayer = bNotifyPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.K2_GiveItemToPlayer
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UFortWorldItemDefinition*   ItemDefinition                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberToGive                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNotifyPlayer                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::K2_GiveItemToPlayer(class AFortPlayerController* PlayerController, const class UFortWorldItemDefinition* ItemDefinition, int32 NumberToGive, bool bNotifyPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_GiveItemToPlayer");

	Params::FortKismetLibrary_K2_GiveItemToPlayer Parms{};

	Parms.PlayerController = PlayerController;
	Parms.ItemDefinition = ItemDefinition;
	Parms.NumberToGive = NumberToGive;
	Parms.bNotifyPlayer = bNotifyPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.K2_RemoveItemFromAllPlayers
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   AmountToRemove                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::K2_RemoveItemFromAllPlayers(class UObject* WorldContextObject, class UFortWorldItemDefinition* ItemDefinition, int32 AmountToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_RemoveItemFromAllPlayers");

	Params::FortKismetLibrary_K2_RemoveItemFromAllPlayers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ItemDefinition = ItemDefinition;
	Parms.AmountToRemove = AmountToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.K2_RemoveItemFromPlayer
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            PlayerController                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   AmountToRemove                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortKismetLibrary::K2_RemoveItemFromPlayer(class AFortPlayerController* PlayerController, class UFortWorldItemDefinition* ItemDefinition, int32 AmountToRemove)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_RemoveItemFromPlayer");

	Params::FortKismetLibrary_K2_RemoveItemFromPlayer Parms{};

	Parms.PlayerController = PlayerController;
	Parms.ItemDefinition = ItemDefinition;
	Parms.AmountToRemove = AmountToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.K2_SpawnPickupInWorld
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortWorldItemDefinition*         ItemDefinition                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberToSpawn                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Position                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   OverrideMaxStackCount                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::K2_SpawnPickupInWorld(class UObject* WorldContextObject, class UFortWorldItemDefinition* ItemDefinition, int32 NumberToSpawn, const struct FVector& Position, const struct FVector& Direction, int32 OverrideMaxStackCount)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "K2_SpawnPickupInWorld");

	Params::FortKismetLibrary_K2_SpawnPickupInWorld Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ItemDefinition = ItemDefinition;
	Parms.NumberToSpawn = NumberToSpawn;
	Parms.Position = std::move(Position);
	Parms.Direction = std::move(Direction);
	Parms.OverrideMaxStackCount = OverrideMaxStackCount;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.MakeAllPlayersTalkToSelf
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NativeAccessSpecifierPublic)
// class USoundBase*                       Audio                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Delay                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterruptCurrentLine                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    bCanBeInterrupted                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// bool                                    bCanCue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// EFortFeedbackBroadcastFilter            BroadcastFilter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLatent                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)

void UFortKismetLibrary::MakeAllPlayersTalkToSelf(class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo, class USoundBase* Audio, float Delay, bool bInterruptCurrentLine, bool bCanBeInterrupted, bool bCanCue, EFortFeedbackBroadcastFilter BroadcastFilter, bool bLatent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeAllPlayersTalkToSelf");

	Params::FortKismetLibrary_MakeAllPlayersTalkToSelf Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);
	Parms.Audio = Audio;
	Parms.Delay = Delay;
	Parms.bInterruptCurrentLine = bInterruptCurrentLine;
	Parms.bCanBeInterrupted = bCanBeInterrupted;
	Parms.bCanCue = bCanCue;
	Parms.BroadcastFilter = BroadcastFilter;
	Parms.bLatent = bLatent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.MakeBuildingState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortBuildingState                      Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortBuildingState                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortBuildingState UFortKismetLibrary::MakeBuildingState(EFortBuildingState Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeBuildingState");

	Params::FortKismetLibrary_MakeBuildingState Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeDayNightPhase
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortDayPhase                           Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortDayPhase UFortKismetLibrary::MakeDayNightPhase(EFortDayPhase Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeDayNightPhase");

	Params::FortKismetLibrary_MakeDayNightPhase Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeGameplayEffectContainerSpecFromAbility
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortGameplayEffectContainer&EffectContainer                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 Ability                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GameplayEffectLevel                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortGameplayEffectContainerSpec ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortGameplayEffectContainerSpec UFortKismetLibrary::MakeGameplayEffectContainerSpecFromAbility(const struct FFortGameplayEffectContainer& EffectContainer, class UGameplayAbility* Ability, int32 GameplayEffectLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeGameplayEffectContainerSpecFromAbility");

	Params::FortKismetLibrary_MakeGameplayEffectContainerSpecFromAbility Parms{};

	Parms.EffectContainer = std::move(EffectContainer);
	Parms.Ability = Ability;
	Parms.GameplayEffectLevel = GameplayEffectLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeGameplayEffectContainerSpecFromAbilityComponent
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FFortGameplayEffectContainer&EffectContainer                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UAbilitySystemComponent*          AbilityComp                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   GameplayEffectLevel                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortGameplayEffectContainerSpec ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortGameplayEffectContainerSpec UFortKismetLibrary::MakeGameplayEffectContainerSpecFromAbilityComponent(const struct FFortGameplayEffectContainer& EffectContainer, class UAbilitySystemComponent* AbilityComp, int32 GameplayEffectLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeGameplayEffectContainerSpecFromAbilityComponent");

	Params::FortKismetLibrary_MakeGameplayEffectContainerSpecFromAbilityComponent Parms{};

	Parms.EffectContainer = std::move(EffectContainer);
	Parms.AbilityComp = AbilityComp;
	Parms.GameplayEffectLevel = GameplayEffectLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeMovementStyle
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortMovementStyle                      Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortMovementStyle                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortMovementStyle UFortKismetLibrary::MakeMovementStyle(EFortMovementStyle Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeMovementStyle");

	Params::FortKismetLibrary_MakeMovementStyle Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeResourceType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortResourceType                       Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortResourceType                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortResourceType UFortKismetLibrary::MakeResourceType(EFortResourceType Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeResourceType");

	Params::FortKismetLibrary_MakeResourceType Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.MakeWeaponCoreAnimation
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortWeaponCoreAnimation                Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortWeaponCoreAnimation                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortWeaponCoreAnimation UFortKismetLibrary::MakeWeaponCoreAnimation(EFortWeaponCoreAnimation Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "MakeWeaponCoreAnimation");

	Params::FortKismetLibrary_MakeWeaponCoreAnimation Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.OnSameTeam
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AActor*                     ActorA                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     ActorB                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::OnSameTeam(const class AActor* ActorA, const class AActor* ActorB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "OnSameTeam");

	Params::FortKismetLibrary_OnSameTeam Parms{};

	Parms.ActorA = ActorA;
	Parms.ActorB = ActorB;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.PickLootDrops
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// TArray<struct FFortItemEntry>*          OutLootToDrop                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const class FName                       TierGroupName                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             WorldLevel                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             ForcedLootTier                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ELootQuotaLevel                   QuotaLevel                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::PickLootDrops(TArray<struct FFortItemEntry>* OutLootToDrop, const class FName TierGroupName, const int32 WorldLevel, const int32 ForcedLootTier, const ELootQuotaLevel QuotaLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "PickLootDrops");

	Params::FortKismetLibrary_PickLootDrops Parms{};

	Parms.TierGroupName = TierGroupName;
	Parms.WorldLevel = WorldLevel;
	Parms.ForcedLootTier = ForcedLootTier;
	Parms.QuotaLevel = QuotaLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLootToDrop != nullptr)
		*OutLootToDrop = std::move(Parms.OutLootToDrop);
}


// Function FortniteGame.FortKismetLibrary.PushOffHitLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           RequestedBy                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector UFortKismetLibrary::PushOffHitLocation(class AActor* RequestedBy, const struct FHitResult& Hit, float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "PushOffHitLocation");

	Params::FortKismetLibrary_PushOffHitLocation Parms{};

	Parms.RequestedBy = RequestedBy;
	Parms.Hit = std::move(Hit);
	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.PushOffTransformByHitLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                           RequestedBy                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                InTransform                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UFortKismetLibrary::PushOffTransformByHitLocation(class AActor* RequestedBy, const struct FTransform& InTransform, const struct FHitResult& Hit, float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "PushOffTransformByHitLocation");

	Params::FortKismetLibrary_PushOffTransformByHitLocation Parms{};

	Parms.RequestedBy = RequestedBy;
	Parms.InTransform = std::move(InTransform);
	Parms.Hit = std::move(Hit);
	Parms.Distance = Distance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.RegisterDayPhaseHitCallback
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Object                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    FunctionName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           Phase                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRecurring                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bBlockTriggeringThisCycle                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::RegisterDayPhaseHitCallback(class UObject* Object, const class FString& FunctionName, EFortDayPhase Phase, bool bRecurring, bool bBlockTriggeringThisCycle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "RegisterDayPhaseHitCallback");

	Params::FortKismetLibrary_RegisterDayPhaseHitCallback Parms{};

	Parms.Object = Object;
	Parms.FunctionName = std::move(FunctionName);
	Parms.Phase = Phase;
	Parms.bRecurring = bRecurring;
	Parms.bBlockTriggeringThisCycle = bBlockTriggeringThisCycle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.RegisterDayTimeHitCallback
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          Object                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    FunctionName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeInHours                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRecurring                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bBlockTriggeringThisCycle                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::RegisterDayTimeHitCallback(class UObject* Object, const class FString& FunctionName, float TimeInHours, bool bRecurring, bool bBlockTriggeringThisCycle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "RegisterDayTimeHitCallback");

	Params::FortKismetLibrary_RegisterDayTimeHitCallback Parms{};

	Parms.Object = Object;
	Parms.FunctionName = std::move(FunctionName);
	Parms.TimeInHours = TimeInHours;
	Parms.bRecurring = bRecurring;
	Parms.bBlockTriggeringThisCycle = bBlockTriggeringThisCycle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.RemoveActorsOfClassFromBuildingSMActorArray
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<class ABuildingSMActor*>&  ArrayToRemoveClassFrom                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TSubclassOf<class ABuildingSMActor>     ClassToRemove                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class ABuildingSMActor*>*        ArrayWithClassRemoved                                  (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::RemoveActorsOfClassFromBuildingSMActorArray(const TArray<class ABuildingSMActor*>& ArrayToRemoveClassFrom, TSubclassOf<class ABuildingSMActor> ClassToRemove, TArray<class ABuildingSMActor*>* ArrayWithClassRemoved)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "RemoveActorsOfClassFromBuildingSMActorArray");

	Params::FortKismetLibrary_RemoveActorsOfClassFromBuildingSMActorArray Parms{};

	Parms.ArrayToRemoveClassFrom = std::move(ArrayToRemoveClassFrom);
	Parms.ClassToRemove = ClassToRemove;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ArrayWithClassRemoved != nullptr)
		*ArrayWithClassRemoved = std::move(Parms.ArrayWithClassRemoved);
}


// Function FortniteGame.FortKismetLibrary.SelectMaterialInstance
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UMaterialInstance*                A                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UMaterialInstance*                B                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSelectA                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class UMaterialInstance*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UMaterialInstance* UFortKismetLibrary::SelectMaterialInstance(class UMaterialInstance* A, class UMaterialInstance* B, bool bSelectA)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SelectMaterialInstance");

	Params::FortKismetLibrary_SelectMaterialInstance Parms{};

	Parms.A = A;
	Parms.B = B;
	Parms.bSelectA = bSelectA;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.SetCanBeDamaged
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCanBeDamaged                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::SetCanBeDamaged(class AActor* Actor, bool bCanBeDamaged)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SetCanBeDamaged");

	Params::FortKismetLibrary_SetCanBeDamaged Parms{};

	Parms.Actor = Actor;
	Parms.bCanBeDamaged = bCanBeDamaged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.SetTimeOfDay
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeOfDay                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::SetTimeOfDay(class UObject* WorldContextObject, float TimeOfDay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SetTimeOfDay");

	Params::FortKismetLibrary_SetTimeOfDay Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TimeOfDay = TimeOfDay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.SetTimeOfDaySpeed
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeOfDaySpeedFactor                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::SetTimeOfDaySpeed(class UObject* WorldContextObject, float TimeOfDaySpeedFactor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SetTimeOfDaySpeed");

	Params::FortKismetLibrary_SetTimeOfDaySpeed Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TimeOfDaySpeedFactor = TimeOfDaySpeedFactor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.ShouldHideTutorialWidget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::ShouldHideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "ShouldHideTutorialWidget");

	Params::FortKismetLibrary_ShouldHideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.SpawnAreaOfEffectCloud
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class AFortAreaOfEffectCloud>AreaOfEffectClass                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           RequestedBy                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnHit                        (Parm, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnExplode                    (Parm, NativeAccessSpecifierPublic)
// class AFortAreaOfEffectCloud*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortAreaOfEffectCloud* UFortKismetLibrary::SpawnAreaOfEffectCloud(TSubclassOf<class AFortAreaOfEffectCloud> AreaOfEffectClass, class AActor* RequestedBy, const struct FVector& SpawnLocation, const struct FRotator& SpawnRotation, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnHit, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnExplode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SpawnAreaOfEffectCloud");

	Params::FortKismetLibrary_SpawnAreaOfEffectCloud Parms{};

	Parms.AreaOfEffectClass = AreaOfEffectClass;
	Parms.RequestedBy = RequestedBy;
	Parms.SpawnLocation = std::move(SpawnLocation);
	Parms.SpawnRotation = std::move(SpawnRotation);
	Parms.EffectContainerSpecToApplyOnHit = std::move(EffectContainerSpecToApplyOnHit);
	Parms.EffectContainerSpecToApplyOnExplode = std::move(EffectContainerSpecToApplyOnExplode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.SpawnBuildingGameplayActor
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class ABuildingGameplayActor>BGAClass                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                Transform                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AFortPawn*                        Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ABuildingGameplayActor*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingGameplayActor* UFortKismetLibrary::SpawnBuildingGameplayActor(TSubclassOf<class ABuildingGameplayActor> BGAClass, const struct FTransform& Transform, class AFortPawn* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SpawnBuildingGameplayActor");

	Params::FortKismetLibrary_SpawnBuildingGameplayActor Parms{};

	Parms.BGAClass = BGAClass;
	Parms.Transform = std::move(Transform);
	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.SpawnProjectile
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// TSubclassOf<class AFortProjectileBase>  ProjectileClass                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           RequestedBy                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnRotation                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FRotator&                  SpawnDirection                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnHit                        (Parm, NativeAccessSpecifierPublic)
// const struct FFortGameplayEffectContainerSpec&EffectContainerSpecToApplyOnExplode                    (Parm, NativeAccessSpecifierPublic)
// bool                                    bUseDefaultPhysics                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// class AActor*                           HomingTarget                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InitialSpeed                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GravityScale                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ChargePercent                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortProjectileBase*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortProjectileBase* UFortKismetLibrary::SpawnProjectile(TSubclassOf<class AFortProjectileBase> ProjectileClass, class AActor* RequestedBy, const struct FVector& SpawnLocation, const struct FRotator& SpawnRotation, const struct FRotator& SpawnDirection, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnHit, const struct FFortGameplayEffectContainerSpec& EffectContainerSpecToApplyOnExplode, bool bUseDefaultPhysics, class AActor* HomingTarget, float InitialSpeed, float GravityScale, float ChargePercent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SpawnProjectile");

	Params::FortKismetLibrary_SpawnProjectile Parms{};

	Parms.ProjectileClass = ProjectileClass;
	Parms.RequestedBy = RequestedBy;
	Parms.SpawnLocation = std::move(SpawnLocation);
	Parms.SpawnRotation = std::move(SpawnRotation);
	Parms.SpawnDirection = std::move(SpawnDirection);
	Parms.EffectContainerSpecToApplyOnHit = std::move(EffectContainerSpecToApplyOnHit);
	Parms.EffectContainerSpecToApplyOnExplode = std::move(EffectContainerSpecToApplyOnExplode);
	Parms.bUseDefaultPhysics = bUseDefaultPhysics;
	Parms.HomingTarget = HomingTarget;
	Parms.InitialSpeed = InitialSpeed;
	Parms.GravityScale = GravityScale;
	Parms.ChargePercent = ChargePercent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.SwitchHeroType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    NewHeroName                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortKismetLibrary::SwitchHeroType(class AFortPlayerController* FortPC, const class FString& NewHeroName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "SwitchHeroType");

	Params::FortKismetLibrary_SwitchHeroType Parms{};

	Parms.FortPC = FortPC;
	Parms.NewHeroName = std::move(NewHeroName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortKismetLibrary.TriggerFeedbackEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortFeedbackHandle&       EventHandle                                            (Parm, NativeAccessSpecifierPublic)
// class AFortPawn*                        InstigatorPawn                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPawn*                        Recipient                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   OverriddenDelay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAllowReplication                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortKismetLibrary::TriggerFeedbackEvent(class UObject* WorldContextObject, const struct FFortFeedbackHandle& EventHandle, class AFortPawn* InstigatorPawn, class AFortPawn* Recipient, float OverriddenDelay, bool bAllowReplication)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "TriggerFeedbackEvent");

	Params::FortKismetLibrary_TriggerFeedbackEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.EventHandle = std::move(EventHandle);
	Parms.InstigatorPawn = InstigatorPawn;
	Parms.Recipient = Recipient;
	Parms.OverriddenDelay = OverriddenDelay;
	Parms.bAllowReplication = bAllowReplication;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.UnequipFortAbilitySet
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FFortAbilitySetHandle&           AbilitySetHandle                                       (Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UFortKismetLibrary::UnequipFortAbilitySet(struct FFortAbilitySetHandle& AbilitySetHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "UnequipFortAbilitySet");

	Params::FortKismetLibrary_UnequipFortAbilitySet Parms{};

	Parms.AbilitySetHandle = std::move(AbilitySetHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	AbilitySetHandle = std::move(Parms.AbilitySetHandle);
}


// Function FortniteGame.FortKismetLibrary.UnhideAllTutorialWidgets
// (Final, Native, Static, Public, BlueprintCallable)

void UFortKismetLibrary::UnhideAllTutorialWidgets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "UnhideAllTutorialWidgets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortKismetLibrary.UnhideTutorialWidget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class FName                             WidgetName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortKismetLibrary::UnhideTutorialWidget(class FName WidgetName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortKismetLibrary", "UnhideTutorialWidget");

	Params::FortKismetLibrary_UnhideTutorialWidget Parms{};

	Parms.WidgetName = WidgetName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLevelScriptActor.OnMatchStarted
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortLevelScriptActor::OnMatchStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLevelScriptActor", "OnMatchStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortLevelScriptActor.OnWorldReady
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)

void AFortLevelScriptActor::OnWorldReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLevelScriptActor", "OnWorldReady");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortLobbyBeaconClientPvP.ServerReadyUp
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortLobbyBeaconClientPvP::ServerReadyUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconClientPvP", "ServerReadyUp");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortLobbyBeaconStatePvP.OnRep_PvPLobbyTimeRemaining
// (Native, Protected)

void AFortLobbyBeaconStatePvP::OnRep_PvPLobbyTimeRemaining()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortLobbyBeaconStatePvP", "OnRep_PvPLobbyTimeRemaining");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMarkActor.OnRep_AttachedToActor
// (Final, Native, Public)

void AFortMarkActor::OnRep_AttachedToActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMarkActor", "OnRep_AttachedToActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionInterface.BlueprintHandleMissionEventNoReply
// (BlueprintAuthorityOnly, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortMissionEvent&         MissionEvent                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void IFortMissionInterface::BlueprintHandleMissionEventNoReply(const struct FFortMissionEvent& MissionEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionInterface", "BlueprintHandleMissionEventNoReply");

	Params::FortMissionInterface_BlueprintHandleMissionEventNoReply Parms{};

	Parms.MissionEvent = std::move(MissionEvent);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMissionManager.OnRep_CurrentTimedMission
// (Native, Protected)

void AFortMissionManager::OnRep_CurrentTimedMission()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionManager", "OnRep_CurrentTimedMission");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionManager.OnRep_Missions
// (Native, Protected)

void AFortMissionManager::OnRep_Missions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionManager", "OnRep_Missions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionManager.OnRep_MissionUIActors
// (Native, Protected)

void AFortMissionManager::OnRep_MissionUIActors()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionManager", "OnRep_MissionUIActors");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPvPMission_3PtDomination.CapturePointSetterHackTimer
// (Native, Protected)

void AFortPvPMission_3PtDomination::CapturePointSetterHackTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPvPMission_3PtDomination", "CapturePointSetterHackTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.ClearMissionTimer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortMissionTimerComponent::ClearMissionTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "ClearMissionTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.DummyTimer
// (Final, Native, Protected)

void UFortMissionTimerComponent::DummyTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "DummyTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.OnRep_TimerData
// (Final, Native, Protected)

void UFortMissionTimerComponent::OnRep_TimerData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "OnRep_TimerData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.PauseMissionTimer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortMissionTimerComponent::PauseMissionTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "PauseMissionTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.ResetMissionTimer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortMissionTimerComponent::ResetMissionTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "ResetMissionTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.SetMissionTimer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    FunctionName                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimerLength                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionTimerComponent::SetMissionTimer(const class FString& FunctionName, float TimerLength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "SetMissionTimer");

	Params::FortMissionTimerComponent_SetMissionTimer Parms{};

	Parms.FunctionName = std::move(FunctionName);
	Parms.TimerLength = TimerLength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.SetTimerDisplayFormat
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bNewDisplayInTimeFormat                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMissionTimerComponent::SetTimerDisplayFormat(bool bNewDisplayInTimeFormat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "SetTimerDisplayFormat");

	Params::FortMissionTimerComponent_SetTimerDisplayFormat Parms{};

	Parms.bNewDisplayInTimeFormat = bNewDisplayInTimeFormat;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.SetTimerLabelText
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// const class FText&                      NewLabelText                                           (Parm, NativeAccessSpecifierPublic)

void UFortMissionTimerComponent::SetTimerLabelText(const class FText& NewLabelText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "SetTimerLabelText");

	Params::FortMissionTimerComponent_SetTimerLabelText Parms{};

	Parms.NewLabelText = std::move(NewLabelText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.SetTimerVisibilityOverrideSetting
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// ETimerOverrideSetting                   NewVisibilitySetting                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMissionTimerComponent::SetTimerVisibilityOverrideSetting(ETimerOverrideSetting NewVisibilitySetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "SetTimerVisibilityOverrideSetting");

	Params::FortMissionTimerComponent_SetTimerVisibilityOverrideSetting Parms{};

	Parms.NewVisibilitySetting = NewVisibilitySetting;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.UnpauseMissionTimer
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void UFortMissionTimerComponent::UnpauseMissionTimer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "UnpauseMissionTimer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMissionTimerComponent.GetMissionTimerTimeRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortMissionTimerComponent::GetMissionTimerTimeRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "GetMissionTimerTimeRemaining");

	Params::FortMissionTimerComponent_GetMissionTimerTimeRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionTimerComponent.GetNormalizedTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortMissionTimerComponent::GetNormalizedTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "GetNormalizedTime");

	Params::FortMissionTimerComponent_GetNormalizedTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionTimerComponent.IsMissionTimerPaused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionTimerComponent::IsMissionTimerPaused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "IsMissionTimerPaused");

	Params::FortMissionTimerComponent_IsMissionTimerPaused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMissionTimerComponent.IsMissionTimerSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortMissionTimerComponent::IsMissionTimerSet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMissionTimerComponent", "IsMissionTimerSet");

	Params::FortMissionTimerComponent_IsMissionTimerSet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMusicManager.ChangeMusic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USoundBase*                       NewMusic                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMusicFadeStyles                        FadeStyle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USoundBase*                       Stinger                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMusicManager::ChangeMusic(class USoundBase* NewMusic, EMusicFadeStyles FadeStyle, float FadeTime, class USoundBase* Stinger)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMusicManager", "ChangeMusic");

	Params::FortMusicManager_ChangeMusic Parms{};

	Parms.NewMusic = NewMusic;
	Parms.FadeStyle = FadeStyle;
	Parms.FadeTime = FadeTime;
	Parms.Stinger = Stinger;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMusicManager.GetEventHeatPercent
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortCombatEvents                       CombatEvent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortMusicManager::GetEventHeatPercent(EFortCombatEvents CombatEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMusicManager", "GetEventHeatPercent");

	Params::FortMusicManager_GetEventHeatPercent Parms{};

	Parms.CombatEvent = CombatEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMusicManager.GetEventHeatPercentTotal
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EFortCombatEvents                       CombatEvent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortMusicManager::GetEventHeatPercentTotal(EFortCombatEvents CombatEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMusicManager", "GetEventHeatPercentTotal");

	Params::FortMusicManager_GetEventHeatPercentTotal Parms{};

	Parms.CombatEvent = CombatEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortMusicManager.OnDayPhaseChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortDayPhase                           CurrentDayPhase                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortDayPhase                           PreviousDayPhase                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAtCreation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortMusicManager::OnDayPhaseChanged(EFortDayPhase CurrentDayPhase, EFortDayPhase PreviousDayPhase, bool bAtCreation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMusicManager", "OnDayPhaseChanged");

	Params::FortMusicManager_OnDayPhaseChanged Parms{};

	Parms.CurrentDayPhase = CurrentDayPhase;
	Parms.PreviousDayPhase = PreviousDayPhase;
	Parms.bAtCreation = bAtCreation;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortMusicManager.OnThresholdChange
// (Event, Public, BlueprintEvent)
// Parameters:
// EFortCombatThresholds                   OldThreshold                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortCombatThresholds                   NewThreshold                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortMusicManager::OnThresholdChange(EFortCombatThresholds OldThreshold, EFortCombatThresholds NewThreshold)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMusicManager", "OnThresholdChange");

	Params::FortMusicManager_OnThresholdChange Parms{};

	Parms.OldThreshold = OldThreshold;
	Parms.NewThreshold = NewThreshold;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortNavSystem.OnNavDataRegistered
// (Final, Native, Protected)
// Parameters:
// class ANavigationData*                  NavData                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortNavSystem::OnNavDataRegistered(class ANavigationData* NavData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortNavSystem", "OnNavDataRegistered");

	Params::FortNavSystem_OnNavDataRegistered Parms{};

	Parms.NavData = NavData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrackMovementComponent.FlipDirection
// (Final, Native, Public, BlueprintCallable)

void UFortTrackMovementComponent::FlipDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "FlipDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrackMovementComponent.OnRep_ReplicatedTrackMovement
// (Final, Native, Private)

void UFortTrackMovementComponent::OnRep_ReplicatedTrackMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "OnRep_ReplicatedTrackMovement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTrackMovementComponent.GetDistanceAlongSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UFortTrackMovementComponent::GetDistanceAlongSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "GetDistanceAlongSpline");

	Params::FortTrackMovementComponent_GetDistanceAlongSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrackMovementComponent.GetSpline
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USplineComponent*                 ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USplineComponent* UFortTrackMovementComponent::GetSpline() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "GetSpline");

	Params::FortTrackMovementComponent_GetSpline Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrackMovementComponent.GetTrack
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortTrack*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortTrack* UFortTrackMovementComponent::GetTrack() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "GetTrack");

	Params::FortTrackMovementComponent_GetTrack Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTrackMovementComponent.IsReverseDirection
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortTrackMovementComponent::IsReverseDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTrackMovementComponent", "IsReverseDirection");

	Params::FortTrackMovementComponent_IsReverseDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityKitTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAbilityKitTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityKitTooltip", "GetTextForToken");

	Params::FortAbilityKitTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityKitTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortAbilityKitTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityKitTooltip", "GetTokenizedDescriptionText");

	Params::FortAbilityKitTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortWeap_BuildingTool.OnBlueprintPaperPulseUpdate
// (Final, Native, Private)
// Parameters:
// float                                   InCurveVal                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortWeap_BuildingTool::OnBlueprintPaperPulseUpdate(float InCurveVal)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeap_BuildingTool", "OnBlueprintPaperPulseUpdate");

	Params::FortWeap_BuildingTool_OnBlueprintPaperPulseUpdate Parms{};

	Parms.InCurveVal = InCurveVal;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeap_BuildingTool.OnRep_DefaultMetadata
// (Final, Native, Private)

void AFortWeap_BuildingTool::OnRep_DefaultMetadata()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeap_BuildingTool", "OnRep_DefaultMetadata");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostFunctionLibrary.GetEnemyGameplayEffectDictatedByPrestige
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayEffect>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UGameplayEffect> UFortOutpostFunctionLibrary::GetEnemyGameplayEffectDictatedByPrestige(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostFunctionLibrary", "GetEnemyGameplayEffectDictatedByPrestige");

	Params::FortOutpostFunctionLibrary_GetEnemyGameplayEffectDictatedByPrestige Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostFunctionLibrary.GetOutpostOwner
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPlayerControllerOutpost*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPlayerControllerOutpost* UFortOutpostFunctionLibrary::GetOutpostOwner(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostFunctionLibrary", "GetOutpostOwner");

	Params::FortOutpostFunctionLibrary_GetOutpostOwner Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostFunctionLibrary.GetOutpostQuestMissionConfigData
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              ConfigTag                                              (Parm, NativeAccessSpecifierPublic)
// class UFortMissionConfigData*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortMissionConfigData* UFortOutpostFunctionLibrary::GetOutpostQuestMissionConfigData(class UObject* WorldContextObject, const struct FGameplayTag& ConfigTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostFunctionLibrary", "GetOutpostQuestMissionConfigData");

	Params::FortOutpostFunctionLibrary_GetOutpostQuestMissionConfigData Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ConfigTag = std::move(ConfigTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortOutpostFunctionLibrary.SetOutpostDefenseActive
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bActive                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortOutpostFunctionLibrary::SetOutpostDefenseActive(class UObject* WorldContextObject, bool bActive)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostFunctionLibrary", "SetOutpostDefenseActive");

	Params::FortOutpostFunctionLibrary_SetOutpostDefenseActive Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bActive = bActive;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortOutpostFunctionLibrary.SetOutpostGameDifficultyRow
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDataTableRowHandle&       GameDifficultyInfo                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UFortOutpostFunctionLibrary::SetOutpostGameDifficultyRow(class UObject* WorldContextObject, const struct FDataTableRowHandle& GameDifficultyInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortOutpostFunctionLibrary", "SetOutpostGameDifficultyRow");

	Params::FortOutpostFunctionLibrary_SetOutpostGameDifficultyRow Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.GameDifficultyInfo = std::move(GameDifficultyInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortAbilityDecoTool.AbilitySpawnDeco
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FAbilityToolSpawnParameters&SpawnParameters                                        (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class ABuildingActor*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class ABuildingActor* AFortAbilityDecoTool::AbilitySpawnDeco(const struct FAbilityToolSpawnParameters& SpawnParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityDecoTool", "AbilitySpawnDeco");

	Params::FortAbilityDecoTool_AbilitySpawnDeco Parms{};

	Parms.SpawnParameters = std::move(SpawnParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityDecoTool.GetPlacementAbilityHandle
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// struct FGameplayAbilitySpecHandle       ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameplayAbilitySpecHandle AFortAbilityDecoTool::GetPlacementAbilityHandle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityDecoTool", "GetPlacementAbilityHandle");

	Params::FortAbilityDecoTool_GetPlacementAbilityHandle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityDecoTool.GetPlacementAbilityInstance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortGameplayAbility*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortGameplayAbility* AFortAbilityDecoTool::GetPlacementAbilityInstance()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityDecoTool", "GetPlacementAbilityInstance");

	Params::FortAbilityDecoTool_GetPlacementAbilityInstance Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortAbilityDecoTool.GetSpawnParameters
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FAbilityToolSpawnParameters*     OutSpawnParamters                                      (Parm, OutParm, NativeAccessSpecifierPublic)

void AFortAbilityDecoTool::GetSpawnParameters(struct FAbilityToolSpawnParameters* OutSpawnParamters) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortAbilityDecoTool", "GetSpawnParameters");

	Params::FortAbilityDecoTool_GetSpawnParameters Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSpawnParamters != nullptr)
		*OutSpawnParamters = std::move(Parms.OutSpawnParamters);
}


// Function FortniteGame.FortPawn_InteractablePawn.BlueprintOnBeginInteract
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)

void AFortPawn_InteractablePawn::BlueprintOnBeginInteract()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn_InteractablePawn", "BlueprintOnBeginInteract");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn_InteractablePawn.BlueprintOnInteract
// (BlueprintAuthorityOnly, Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPawn_InteractablePawn::BlueprintOnInteract(const class AFortPawn* InteractingPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn_InteractablePawn", "BlueprintOnInteract");

	Params::FortPawn_InteractablePawn_BlueprintOnInteract Parms{};

	Parms.InteractingPawn = InteractingPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPawn_InteractablePawn.BlueprintCanInteract
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPawn_InteractablePawn::BlueprintCanInteract(const class AFortPawn* InteractingPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn_InteractablePawn", "BlueprintCanInteract");

	Params::FortPawn_InteractablePawn_BlueprintCanInteract Parms{};

	Parms.InteractingPawn = InteractingPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPawn_InteractablePawn.BlueprintGetInteractionString
// (Native, Event, Public, BlueprintEvent, Const)
// Parameters:
// const class AFortPawn*                  InteractingPawn                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText AFortPawn_InteractablePawn::BlueprintGetInteractionString(const class AFortPawn* InteractingPawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPawn_InteractablePawn", "BlueprintGetInteractionString");

	Params::FortPawn_InteractablePawn_BlueprintGetInteractionString Parms{};

	Parms.InteractingPawn = InteractingPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.CalculateTotalWorkerRatings
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<class UHomeBaseWorker*>&   Workers_0                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UHomeBaseWorkers::CalculateTotalWorkerRatings(const TArray<class UHomeBaseWorker*>& Workers_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "CalculateTotalWorkerRatings");

	Params::HomeBaseWorkers_CalculateTotalWorkerRatings Parms{};

	Parms.Workers_0 = std::move(Workers_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.GetAllManagers
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class UHomeBaseWorker*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UHomeBaseWorker*> UHomeBaseWorkers::GetAllManagers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "GetAllManagers");

	Params::HomeBaseWorkers_GetAllManagers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.GetAllWorkers
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class UHomeBaseWorker*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UHomeBaseWorker*> UHomeBaseWorkers::GetAllWorkers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "GetAllWorkers");

	Params::HomeBaseWorkers_GetAllWorkers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.GetSlots
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FHomeBaseWorkerSlot>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FHomeBaseWorkerSlot> UHomeBaseWorkers::GetSlots()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "GetSlots");

	Params::HomeBaseWorkers_GetSlots Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.GetSlottedWorkers
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class UHomeBaseWorker*>          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UHomeBaseWorker*> UHomeBaseWorkers::GetSlottedWorkers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "GetSlottedWorkers");

	Params::HomeBaseWorkers_GetSlottedWorkers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.GetWorkerFromItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UFortWorker*                WorkerItem                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UHomeBaseWorker*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UHomeBaseWorker* UHomeBaseWorkers::GetWorkerFromItem(const class UFortWorker* WorkerItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "GetWorkerFromItem");

	Params::HomeBaseWorkers_GetWorkerFromItem Parms{};

	Parms.WorkerItem = WorkerItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseWorkers.OnBuildingItemChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bItemChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bAmmoChanged                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIngredientsChanged                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UHomeBaseWorkers::OnBuildingItemChanged(bool bItemChanged, bool bAmmoChanged, bool bIngredientsChanged)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "OnBuildingItemChanged");

	Params::HomeBaseWorkers_OnBuildingItemChanged Parms{};

	Parms.bItemChanged = bItemChanged;
	Parms.bAmmoChanged = bAmmoChanged;
	Parms.bIngredientsChanged = bIngredientsChanged;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseWorkers.SlotWorker
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UHomeBaseWorker*                  Worker                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SlotIndex                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UHomeBaseWorkers::SlotWorker(class UHomeBaseWorker* Worker, int32 SlotIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorkers", "SlotWorker");

	Params::HomeBaseWorkers_SlotWorker Parms{};

	Parms.Worker = Worker;
	Parms.SlotIndex = SlotIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPermaniteStructureInterface.OnBoundariesChanged
// (Event, Public, BlueprintEvent)
// Parameters:
// int32                                   MinLevel                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MaxLevel                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   CurrentLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IFortPermaniteStructureInterface::OnBoundariesChanged(int32 MinLevel, int32 MaxLevel, int32 CurrentLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPermaniteStructureInterface", "OnBoundariesChanged");

	Params::FortPermaniteStructureInterface_OnBoundariesChanged Parms{};

	Parms.MinLevel = MinLevel;
	Parms.MaxLevel = MaxLevel;
	Parms.CurrentLevel = CurrentLevel;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortPickupEffect.OnAboutToEnterBackpack
// (Event, Public, BlueprintEvent)

void AFortPickupEffect::OnAboutToEnterBackpack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickupEffect", "OnAboutToEnterBackpack");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPickupEffect.OnAttached
// (Event, Public, BlueprintEvent)

void AFortPickupEffect::OnAttached()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickupEffect", "OnAttached");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPickupEffect.OnPickedUp
// (Event, Public, BlueprintEvent)

void AFortPickupEffect::OnPickedUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPickupEffect", "OnPickedUp");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortPvPFunctionLibrary.DestroyAllFortPickupsWithItem
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UFortWorldItemDefinition*   ItemDefinitionToCheck                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPvPFunctionLibrary::DestroyAllFortPickupsWithItem(class UObject* WorldContextObject, const class UFortWorldItemDefinition* ItemDefinitionToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "DestroyAllFortPickupsWithItem");

	Params::FortPvPFunctionLibrary_DestroyAllFortPickupsWithItem Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ItemDefinitionToCheck = ItemDefinitionToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPvPFunctionLibrary.GetBaseDestructionTeamInfo
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortTeamInfoPvPBaseDestruction*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortTeamInfoPvPBaseDestruction* UFortPvPFunctionLibrary::GetBaseDestructionTeamInfo(class UObject* WorldContextObject, EFortTeam Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetBaseDestructionTeamInfo");

	Params::FortPvPFunctionLibrary_GetBaseDestructionTeamInfo Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPFunctionLibrary.GetDifficultyRowNamesFromPvPRating
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class FName>*                    OutDifficultyRows                                      (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// const float                             InPvPRating                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPvPFunctionLibrary::GetDifficultyRowNamesFromPvPRating(TArray<class FName>* OutDifficultyRows, const float InPvPRating)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetDifficultyRowNamesFromPvPRating");

	Params::FortPvPFunctionLibrary_GetDifficultyRowNamesFromPvPRating Parms{};

	Parms.InPvPRating = InPvPRating;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDifficultyRows != nullptr)
		*OutDifficultyRows = std::move(Parms.OutDifficultyRows);
}


// Function FortniteGame.FortPvPFunctionLibrary.GetMatchLevel
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortPvPFunctionLibrary::GetMatchLevel(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetMatchLevel");

	Params::FortPvPFunctionLibrary_GetMatchLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPFunctionLibrary.GetRoundTimeAccumulated
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortPvPFunctionLibrary::GetRoundTimeAccumulated(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetRoundTimeAccumulated");

	Params::FortPvPFunctionLibrary_GetRoundTimeAccumulated Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPFunctionLibrary.GetTeamCornerstone
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AFortPvPBaseCornerstone*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPvPBaseCornerstone* UFortPvPFunctionLibrary::GetTeamCornerstone(class UObject* WorldContextObject, EFortTeam Team)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetTeamCornerstone");

	Params::FortPvPFunctionLibrary_GetTeamCornerstone Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Team = Team;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPFunctionLibrary.GetTeamStrategicBuildingActor
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EFortTeam                               Team                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTeamStrategicBuildingHandle&SBAHandle                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class AStrategicBuildingActor*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AStrategicBuildingActor* UFortPvPFunctionLibrary::GetTeamStrategicBuildingActor(class UObject* WorldContextObject, EFortTeam Team, const struct FTeamStrategicBuildingHandle& SBAHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "GetTeamStrategicBuildingActor");

	Params::FortPvPFunctionLibrary_GetTeamStrategicBuildingActor Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Team = Team;
	Parms.SBAHandle = std::move(SBAHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPvPFunctionLibrary.SetMatchLevel
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   MatchLevel                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortPvPFunctionLibrary::SetMatchLevel(class UObject* WorldContextObject, int32 MatchLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortPvPFunctionLibrary", "SetMatchLevel");

	Params::FortPvPFunctionLibrary_SetMatchLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MatchLevel = MatchLevel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIBaseClass.TutorialToggleHUD
// (Final, Native, Public, BlueprintCallable)

void AFortUIBaseClass::TutorialToggleHUD()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIBaseClass", "TutorialToggleHUD");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIZone.ToggleTargetInfo
// (Final, RequiredAPI, Exec, Native, Public)

void AFortUIZone::ToggleTargetInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIZone", "ToggleTargetInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIZone.ToggleTargetInfoAI
// (Final, Exec, Native, Public)

void AFortUIZone::ToggleTargetInfoAI()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIZone", "ToggleTargetInfoAI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIZone.ToggleTargetInfoLock
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bTraceComplex                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortUIZone::ToggleTargetInfoLock(bool bTraceComplex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIZone", "ToggleTargetInfoLock");

	Params::FortUIZone_ToggleTargetInfoLock Parms{};

	Parms.bTraceComplex = bTraceComplex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIZone.ToggleTargetInfoPaths
// (Final, Exec, Native, Public)

void AFortUIZone::ToggleTargetInfoPaths()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIZone", "ToggleTargetInfoPaths");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIZone.ToggleTargetInfoSensing
// (Final, Exec, Native, Public)

void AFortUIZone::ToggleTargetInfoSensing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIZone", "ToggleTargetInfoSensing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerStateOutpost.OnRep_CanEditOutpost
// (Final, Native, Protected)

void AFortPlayerStateOutpost::OnRep_CanEditOutpost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerStateOutpost", "OnRep_CanEditOutpost");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerStateOutpost.OnRep_CraftingTableItemsRemaing
// (Final, Native, Private)

void AFortPlayerStateOutpost::OnRep_CraftingTableItemsRemaing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerStateOutpost", "OnRep_CraftingTableItemsRemaing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerStateOutpost.ServerSetCanEditOutpost
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class AFortPlayerStateOutpost*          InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCanEdit                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerStateOutpost::ServerSetCanEditOutpost(class AFortPlayerStateOutpost* InPlayer, bool bCanEdit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerStateOutpost", "ServerSetCanEditOutpost");

	Params::FortPlayerStateOutpost_ServerSetCanEditOutpost Parms{};

	Parms.InPlayer = InPlayer;
	Parms.bCanEdit = bCanEdit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerStateOutpost.SetCanEditOutpost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerStateOutpost*          InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCanEdit                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerStateOutpost::SetCanEditOutpost(class AFortPlayerStateOutpost* InPlayer, bool bCanEdit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerStateOutpost", "SetCanEditOutpost");

	Params::FortPlayerStateOutpost_SetCanEditOutpost Parms{};

	Parms.InPlayer = InPlayer;
	Parms.bCanEdit = bCanEdit;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerStateOutpost.CanEditOutpost
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerStateOutpost::CanEditOutpost() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerStateOutpost", "CanEditOutpost");

	Params::FortPlayerStateOutpost_CanEditOutpost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerARPG.TogglePointAndClickMovement
// (Final, Exec, Native, Public)

void AFortPlayerControllerARPG::TogglePointAndClickMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerARPG", "TogglePointAndClickMovement");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.ClientSetPermaniteAvailability
// (Final, Net, NetReliable, Native, Event, Private, NetClient)
// Parameters:
// bool                                    bAvailable                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerControllerKeep::ClientSetPermaniteAvailability(bool bAvailable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "ClientSetPermaniteAvailability");

	Params::FortPlayerControllerKeep_ClientSetPermaniteAvailability Parms{};

	Parms.bAvailable = bAvailable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.ClientUnloadFoundations
// (Net, NetReliable, Native, Event, Public, NetClient)

void AFortPlayerControllerKeep::ClientUnloadFoundations()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "ClientUnloadFoundations");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.DumpItemData
// (Final, Exec, Native, Public)

void AFortPlayerControllerKeep::DumpItemData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "DumpItemData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.ResetContainers
// (Final, Exec, Native, Public)

void AFortPlayerControllerKeep::ResetContainers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "ResetContainers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.RestoreContainers
// (Final, Exec, Native, Public)

void AFortPlayerControllerKeep::RestoreContainers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "RestoreContainers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.ServerOnContainerItemsChosen
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class AKeepItemContainer*               Container                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            ItemTemplateIDs                                        (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerControllerKeep::ServerOnContainerItemsChosen(class AKeepItemContainer* Container, const TArray<class FString>& ItemTemplateIDs)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "ServerOnContainerItemsChosen");

	Params::FortPlayerControllerKeep_ServerOnContainerItemsChosen Parms{};

	Parms.Container = Container;
	Parms.ItemTemplateIDs = std::move(ItemTemplateIDs);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.SetPermaniteAvailability
// (Final, Exec, Native, Public)
// Parameters:
// bool                                    bAvailable                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortPlayerControllerKeep::SetPermaniteAvailability(bool bAvailable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "SetPermaniteAvailability");

	Params::FortPlayerControllerKeep_SetPermaniteAvailability Parms{};

	Parms.bAvailable = bAvailable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.StreamInStuff
// (Final, Exec, Native, Public)

void AFortPlayerControllerKeep::StreamInStuff()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "StreamInStuff");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerKeep.StreamOutStuff
// (Final, Exec, Native, Public)

void AFortPlayerControllerKeep::StreamOutStuff()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerKeep", "StreamOutStuff");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ClientExecuteInventoryItem
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Delay                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ClientExecuteInventoryItem(const struct FGuid& ItemGuid, float Delay)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ClientExecuteInventoryItem");

	Params::FortPlayerControllerOutpost_ClientExecuteInventoryItem Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Delay = Delay;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ClientOnStructureLevelChanged
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// class UFortOutpostItemDefinition*       UpgradedStructure                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InLevelBeforeUpgrade                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ClientOnStructureLevelChanged(class UFortOutpostItemDefinition* UpgradedStructure, int32 InLevelBeforeUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ClientOnStructureLevelChanged");

	Params::FortPlayerControllerOutpost_ClientOnStructureLevelChanged Parms{};

	Parms.UpgradedStructure = UpgradedStructure;
	Parms.InLevelBeforeUpgrade = InLevelBeforeUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ClientShowVictoryScreen
// (Final, Net, NetReliable, Native, Event, Private, NetClient)

void AFortPlayerControllerOutpost::ClientShowVictoryScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ClientShowVictoryScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.DumpInventory
// (Final, Exec, Native, Public)

void AFortPlayerControllerOutpost::DumpInventory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "DumpInventory");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.OnRep_DisintegrationStartTime
// (Final, Native, Protected)

void AFortPlayerControllerOutpost::OnRep_DisintegrationStartTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "OnRep_DisintegrationStartTime");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.OnRep_PostDepositedResources
// (Final, Native, Protected)

void AFortPlayerControllerOutpost::OnRep_PostDepositedResources()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "OnRep_PostDepositedResources");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.OnRep_QuantumGooCompleted
// (Final, Native, Protected)

void AFortPlayerControllerOutpost::OnRep_QuantumGooCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "OnRep_QuantumGooCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.OnRep_QuantumGooIncoming
// (Final, Native, Protected)

void AFortPlayerControllerOutpost::OnRep_QuantumGooIncoming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "OnRep_QuantumGooIncoming");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServeMoveItemFromStorageVault
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FFortItemEntry&            NewlyCollectedItem                                     (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServeMoveItemFromStorageVault(const struct FFortItemEntry& NewlyCollectedItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServeMoveItemFromStorageVault");

	Params::FortPlayerControllerOutpost_ServeMoveItemFromStorageVault Parms{};

	Parms.NewlyCollectedItem = std::move(NewlyCollectedItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServeMoveItemToStorageVault
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const struct FFortItemEntry&            NewlyStoredItem                                        (ConstParm, Parm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServeMoveItemToStorageVault(const struct FFortItemEntry& NewlyStoredItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServeMoveItemToStorageVault");

	Params::FortPlayerControllerOutpost_ServeMoveItemToStorageVault Parms{};

	Parms.NewlyStoredItem = std::move(NewlyStoredItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerAbortDisintegration
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerAbortDisintegration()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerAbortDisintegration");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerActivateCraftingTable
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerActivateCraftingTable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerActivateCraftingTable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerDeactivateCraftingTable
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerDeactivateCraftingTable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerDeactivateCraftingTable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerDepositPOSTResource
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServerDepositPOSTResource(const struct FGuid& ItemGuid, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerDepositPOSTResource");

	Params::FortPlayerControllerOutpost_ServerDepositPOSTResource Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerDisintegrateItem
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// const struct FGuid&                     ItemGuid                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServerDisintegrateItem(const struct FGuid& ItemGuid, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerDisintegrateItem");

	Params::FortPlayerControllerOutpost_ServerDisintegrateItem Parms{};

	Parms.ItemGuid = std::move(ItemGuid);
	Parms.Count = Count;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerFabricateItem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// const class UFortWorldItemDefinition*   ItemDef                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServerFabricateItem(const class UFortWorldItemDefinition* ItemDef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerFabricateItem");

	Params::FortPlayerControllerOutpost_ServerFabricateItem Parms{};

	Parms.ItemDef = ItemDef;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerIncreaseOutpostPrestigeLevel
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerIncreaseOutpostPrestigeLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerIncreaseOutpostPrestigeLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerLeaveOutpostAsParty
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerLeaveOutpostAsParty()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerLeaveOutpostAsParty");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerNotifyPendingFabricationCompleted
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerNotifyPendingFabricationCompleted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerNotifyPendingFabricationCompleted");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerUpgradePOST
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortPlayerControllerOutpost::ServerUpgradePOST()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerUpgradePOST");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ServerUpgradeStructure
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// class UFortOutpostItemDefinition*       StructureToUpgrade                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::ServerUpgradeStructure(class UFortOutpostItemDefinition* StructureToUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ServerUpgradeStructure");

	Params::FortPlayerControllerOutpost_ServerUpgradeStructure Parms{};

	Parms.StructureToUpgrade = StructureToUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.ToggleOwnerInPIE
// (Final, Exec, Native, Private)

void AFortPlayerControllerOutpost::ToggleOwnerInPIE()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ToggleOwnerInPIE");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.UpgradeStructure
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UFortOutpostItemDefinition*       StructureToUpgrade                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::UpgradeStructure(class UFortOutpostItemDefinition* StructureToUpgrade)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "UpgradeStructure");

	Params::FortPlayerControllerOutpost_UpgradeStructure Parms{};

	Parms.StructureToUpgrade = StructureToUpgrade;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerControllerOutpost.CanUpgradeStructure
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLog                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerControllerOutpost::CanUpgradeStructure(class UFortOutpostItemDefinition* OutpostStructure, bool bLog) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "CanUpgradeStructure");

	Params::FortPlayerControllerOutpost_CanUpgradeStructure Parms{};

	Parms.OutpostStructure = OutpostStructure;
	Parms.bLog = bLog;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetPendingFabricationProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AFortPlayerControllerOutpost::GetPendingFabricationProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetPendingFabricationProgress");

	Params::FortPlayerControllerOutpost_GetPendingFabricationProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetPendingItemToFabricate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorldItemDefinition*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorldItemDefinition* AFortPlayerControllerOutpost::GetPendingItemToFabricate() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetPendingItemToFabricate");

	Params::FortPlayerControllerOutpost_GetPendingItemToFabricate Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetStormShieldLevelDefended
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortPlayerControllerOutpost::GetStormShieldLevelDefended() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetStormShieldLevelDefended");

	Params::FortPlayerControllerOutpost_GetStormShieldLevelDefended Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetStructureLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortPlayerControllerOutpost::GetStructureLevel(class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetStructureLevel");

	Params::FortPlayerControllerOutpost_GetStructureLevel Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetStructureMaxLevel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortPlayerControllerOutpost::GetStructureMaxLevel(class UFortOutpostItemDefinition* OutpostStructure) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetStructureMaxLevel");

	Params::FortPlayerControllerOutpost_GetStructureMaxLevel Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.GetUpgradeStructureCost
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortOutpostItemDefinition*       OutpostStructure                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutWorldItems                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<struct FFortItemQuantityPair>*   OutAccountItems                                        (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void AFortPlayerControllerOutpost::GetUpgradeStructureCost(class UFortOutpostItemDefinition* OutpostStructure, TArray<struct FFortItemQuantityPair>* OutWorldItems, TArray<struct FFortItemQuantityPair>* OutAccountItems) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "GetUpgradeStructureCost");

	Params::FortPlayerControllerOutpost_GetUpgradeStructureCost Parms{};

	Parms.OutpostStructure = OutpostStructure;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWorldItems != nullptr)
		*OutWorldItems = std::move(Parms.OutWorldItems);

	if (OutAccountItems != nullptr)
		*OutAccountItems = std::move(Parms.OutAccountItems);
}


// Function FortniteGame.FortPlayerControllerOutpost.IsFabricationPending
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerControllerOutpost::IsFabricationPending() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "IsFabricationPending");

	Params::FortPlayerControllerOutpost_IsFabricationPending Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.IsOutpostOwner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerControllerOutpost::IsOutpostOwner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "IsOutpostOwner");

	Params::FortPlayerControllerOutpost_IsOutpostOwner Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerControllerOutpost.ShowOutpostVictoryScreenToAll
// (Final, BlueprintAuthorityOnly, Exec, Native, Public, BlueprintCallable, Const)

void AFortPlayerControllerOutpost::ShowOutpostVictoryScreenToAll() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerControllerOutpost", "ShowOutpostVictoryScreenToAll");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerMannequin.CyclePartBP
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNextPart                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerMannequin::CyclePartBP(EFortCustomPartType Part, bool bNextPart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "CyclePartBP");

	Params::FortPlayerMannequin_CyclePartBP Parms{};

	Parms.Part = Part;
	Parms.bNextPart = bNextPart;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerMannequin.RemovePart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerMannequin::RemovePart(EFortCustomPartType Part)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "RemovePart");

	Params::FortPlayerMannequin_RemovePart Parms{};

	Parms.Part = Part;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerMannequin.SetPart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFortCustomPartType                     Part                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCustomCharacterPart*             PartAsset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerMannequin::SetPart(EFortCustomPartType Part, class UCustomCharacterPart* PartAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "SetPart");

	Params::FortPlayerMannequin_SetPart Parms{};

	Parms.Part = Part;
	Parms.PartAsset = PartAsset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerMannequin.SetSkeletalMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMesh*                    SkeletalMesh                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortPlayerMannequin::SetSkeletalMesh(class USkeletalMesh* SkeletalMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "SetSkeletalMesh");

	Params::FortPlayerMannequin_SetSkeletalMesh Parms{};

	Parms.SkeletalMesh = SkeletalMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerMannequin.SetWeaponSkeletalMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMesh*                    SkeletalMesh                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortPlayerMannequin::SetWeaponSkeletalMesh(class USkeletalMesh* SkeletalMesh)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "SetWeaponSkeletalMesh");

	Params::FortPlayerMannequin_SetWeaponSkeletalMesh Parms{};

	Parms.SkeletalMesh = SkeletalMesh;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortPlayerMannequin.ToggleGenderBP
// (Final, Native, Public, BlueprintCallable)

void AFortPlayerMannequin::ToggleGenderBP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "ToggleGenderBP");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerMannequin.UpdateMorphTargets
// (Native, Public)

void AFortPlayerMannequin::UpdateMorphTargets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "UpdateMorphTargets");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortPlayerMannequin.GetGender
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortCustomGender                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortCustomGender AFortPlayerMannequin::GetGender() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortPlayerMannequin", "GetGender");

	Params::FortPlayerMannequin_GetGender Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestCategory.HasUnseenQuests
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestCategory::HasUnseenQuests() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestCategory", "HasUnseenQuests");

	Params::FortQuestCategory_HasUnseenQuests Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.ClaimNextCompletedQuestReward
// (Final, Native, Public, BlueprintCallable, Const)

void UFortQuestManager::ClaimNextCompletedQuestReward() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "ClaimNextCompletedQuestReward");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuestManager.ClaimQuestReward
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class UFortQuestItem*             Quest                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortQuestManager::ClaimQuestReward(const class UFortQuestItem* Quest) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "ClaimQuestReward");

	Params::FortQuestManager_ClaimQuestReward Parms{};

	Parms.Quest = Quest;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuestManager.GetCurrentQuestsCategories
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UFortQuestCategory*>*      Categories                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UFortQuestManager::GetCurrentQuestsCategories(TArray<class UFortQuestCategory*>* Categories) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "GetCurrentQuestsCategories");

	Params::FortQuestManager_GetCurrentQuestsCategories Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Categories != nullptr)
		*Categories = std::move(Parms.Categories);
}


// Function FortniteGame.FortQuestManager.GetQuestWithDefinition
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortQuestItemDefinition*   Definition                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UFortQuestItem*                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortQuestItem* UFortQuestManager::GetQuestWithDefinition(const class UFortQuestItemDefinition* Definition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "GetQuestWithDefinition");

	Params::FortQuestManager_GetQuestWithDefinition Parms{};

	Parms.Definition = Definition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.GetRemainingDailyQuestRerolls
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UFortQuestManager::GetRemainingDailyQuestRerolls() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "GetRemainingDailyQuestRerolls");

	Params::FortQuestManager_GetRemainingDailyQuestRerolls Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.GetSourceAndContextTags
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameplayTagContainer*           OutSourceTags                                          (Parm, OutParm, NativeAccessSpecifierPublic)
// struct FGameplayTagContainer*           OutContextTags                                         (Parm, OutParm, NativeAccessSpecifierPublic)

void UFortQuestManager::GetSourceAndContextTags(struct FGameplayTagContainer* OutSourceTags, struct FGameplayTagContainer* OutContextTags) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "GetSourceAndContextTags");

	Params::FortQuestManager_GetSourceAndContextTags Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutSourceTags != nullptr)
		*OutSourceTags = std::move(Parms.OutSourceTags);

	if (OutContextTags != nullptr)
		*OutContextTags = std::move(Parms.OutContextTags);
}


// Function FortniteGame.FortQuestManager.GrantFirstDailyQuest
// (Final, Native, Public, BlueprintCallable, Const)

void UFortQuestManager::GrantFirstDailyQuest() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "GrantFirstDailyQuest");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuestManager.HasCompletedObjective
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortQuestItemDefinition*   Definition                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDataTableRowHandle&       ObjectiveStatHandle                                    (Parm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestManager::HasCompletedObjective(const class UFortQuestItemDefinition* Definition, const struct FDataTableRowHandle& ObjectiveStatHandle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "HasCompletedObjective");

	Params::FortQuestManager_HasCompletedObjective Parms{};

	Parms.Definition = Definition;
	Parms.ObjectiveStatHandle = std::move(ObjectiveStatHandle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.HasCompletedQuest
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UFortQuestItemDefinition*   Definition                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestManager::HasCompletedQuest(const class UFortQuestItemDefinition* Definition) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "HasCompletedQuest");

	Params::FortQuestManager_HasCompletedQuest Parms{};

	Parms.Definition = Definition;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.HasUnseenQuests
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortQuestManager::HasUnseenQuests() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "HasUnseenQuests");

	Params::FortQuestManager_HasUnseenQuests Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortQuestManager.MarkQuestSeen
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UFortQuestItem*                   Quest                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortQuestManager::MarkQuestSeen(class UFortQuestItem* Quest) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "MarkQuestSeen");

	Params::FortQuestManager_MarkQuestSeen Parms{};

	Parms.Quest = Quest;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuestManager.MarkQuestsSeen
// (Final, Native, Public, BlueprintCallable, Const)

void UFortQuestManager::MarkQuestsSeen() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "MarkQuestsSeen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortQuestManager.RerollDailyQuest
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class UFortQuestItem*             QuestToDiscard                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortQuestManager::RerollDailyQuest(const class UFortQuestItem* QuestToDiscard) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortQuestManager", "RerollDailyQuest");

	Params::FortQuestManager_RerollDailyQuest Parms{};

	Parms.QuestToDiscard = QuestToDiscard;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortRarityData.BPGetRarityData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EFortRarity                             Rarity                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FFortRarityItemData              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortRarityItemData UFortRarityData::BPGetRarityData(EFortRarity Rarity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("FortRarityData", "BPGetRarityData");

	Params::FortRarityData_BPGetRarityData Parms{};

	Parms.Rarity = Rarity;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSaveFileBuildingInstructionsHandler.AreBuildingsLoaded
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortSaveFileBuildingInstructionsHandler::AreBuildingsLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSaveFileBuildingInstructionsHandler", "AreBuildingsLoaded");

	Params::FortSaveFileBuildingInstructionsHandler_AreBuildingsLoaded Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSaveFileBuildingInstructionsHandler.GetAllSpawnedBuildings
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// TArray<class ABuildingActor*>           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class ABuildingActor*> AFortSaveFileBuildingInstructionsHandler::GetAllSpawnedBuildings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSaveFileBuildingInstructionsHandler", "GetAllSpawnedBuildings");

	Params::FortSaveFileBuildingInstructionsHandler_GetAllSpawnedBuildings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSaveFileBuildingInstructionsHandler.LoadBuildings
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortSaveFileBuildingInstructionsHandler::LoadBuildings(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSaveFileBuildingInstructionsHandler", "LoadBuildings");

	Params::FortSaveFileBuildingInstructionsHandler_LoadBuildings Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSaveFileBuildingInstructionsHandler.ResetBuildings
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortSaveFileBuildingInstructionsHandler::ResetBuildings(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSaveFileBuildingInstructionsHandler", "ResetBuildings");

	Params::FortSaveFileBuildingInstructionsHandler_ResetBuildings Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSaveFileBuildingInstructionsHandler.SaveBuildings
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            FortPC                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortSaveFileBuildingInstructionsHandler::SaveBuildings(class AFortPlayerController* FortPC)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSaveFileBuildingInstructionsHandler", "SaveBuildings");

	Params::FortSaveFileBuildingInstructionsHandler_SaveBuildings Parms{};

	Parms.FortPC = FortPC;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortScriptedAction.CancelAction
// (Final, Native, Public, BlueprintCallable)

void AFortScriptedAction::CancelAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedAction", "CancelAction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortScriptedAction.CompleteAction
// (Final, Native, Protected, BlueprintCallable)

void AFortScriptedAction::CompleteAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedAction", "CompleteAction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortScriptedAction.Execute
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FFortScriptedActionParams& Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortScriptedAction::Execute(const struct FFortScriptedActionParams& Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedAction", "Execute");

	Params::FortScriptedAction_Execute Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortScriptedAction.GetParams
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// struct FFortScriptedActionParams*       Params_0                                               (Parm, OutParm, NativeAccessSpecifierPublic)

void AFortScriptedAction::GetParams(struct FFortScriptedActionParams* Params_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedAction", "GetParams");

	Params::FortScriptedAction_GetParams Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Params_0 != nullptr)
		*Params_0 = std::move(Parms.Params_0);
}


// Function FortniteGame.FortScriptedAction.CanExecute
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FFortScriptedActionParams& Params_0                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortScriptedAction::CanExecute(const struct FFortScriptedActionParams& Params_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedAction", "CanExecute");

	Params::FortScriptedAction_CanExecute Parms{};

	Parms.Params_0 = std::move(Params_0);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortScriptedActionManager.HandleClientEvent_Undefined
// (Final, BlueprintCosmetic, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          EventSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          EventFocus                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FFortClientEvent&          ClientEvent                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void AFortScriptedActionManager::HandleClientEvent_Undefined(class UObject* EventSource, class UObject* EventFocus, const struct FFortClientEvent& ClientEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortScriptedActionManager", "HandleClientEvent_Undefined");

	Params::FortScriptedActionManager_HandleClientEvent_Undefined Parms{};

	Parms.EventSource = EventSource;
	Parms.EventFocus = EventFocus;
	Parms.ClientEvent = std::move(ClientEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortSocialItem.GetBasicInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FFortSocialItemBasicData         ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FFortSocialItemBasicData UFortSocialItem::GetBasicInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItem", "GetBasicInfo");

	Params::FortSocialItem_GetBasicInfo Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSocialItem.GetDisplayName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortSocialItem::GetDisplayName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItem", "GetDisplayName");

	Params::FortSocialItem_GetDisplayName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSocialItem.GetLocation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UFortSocialItem::GetLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItem", "GetLocation");

	Params::FortSocialItem_GetLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSocialItem.GetPresenceStatus
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EFortSocialItemPresenceStatus           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EFortSocialItemPresenceStatus UFortSocialItem::GetPresenceStatus() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItem", "GetPresenceStatus");

	Params::FortSocialItem_GetPresenceStatus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortSocialItem.GetUniquePlayerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FUniqueNetIdRepl                 ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FUniqueNetIdRepl UFortSocialItem::GetUniquePlayerId() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortSocialItem", "GetUniquePlayerId");

	Params::FortSocialItem_GetUniquePlayerId Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTeamInfo.GetTeamExperience
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortTeamInfo::GetTeamExperience() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfo", "GetTeamExperience");

	Params::FortTeamInfo_GetTeamExperience Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTeamInfo.GetTeamLevel
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AFortTeamInfo::GetTeamLevel() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfo", "GetTeamLevel");

	Params::FortTeamInfo_GetTeamLevel Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTeamInfoPvPBaseDestruction.OnRep_TeamExperience
// (Final, Native, Private)

void AFortTeamInfoPvPBaseDestruction::OnRep_TeamExperience()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfoPvPBaseDestruction", "OnRep_TeamExperience");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTeamInfoPvPBaseDestruction.OnRep_TeamLevel
// (Final, Native, Private)

void AFortTeamInfoPvPBaseDestruction::OnRep_TeamLevel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfoPvPBaseDestruction", "OnRep_TeamLevel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTeamInfoPvPBaseDestruction.GetStrategicBuildingActor
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FTeamStrategicBuildingHandle&Handle                                                 (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class AStrategicBuildingActor*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AStrategicBuildingActor* AFortTeamInfoPvPBaseDestruction::GetStrategicBuildingActor(const struct FTeamStrategicBuildingHandle& Handle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfoPvPBaseDestruction", "GetStrategicBuildingActor");

	Params::FortTeamInfoPvPBaseDestruction_GetStrategicBuildingActor Parms{};

	Parms.Handle = std::move(Handle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTeamInfoPvPBaseDestruction.GetTeamCornerstone
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AFortPvPBaseCornerstone*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AFortPvPBaseCornerstone* AFortTeamInfoPvPBaseDestruction::GetTeamCornerstone() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTeamInfoPvPBaseDestruction", "GetTeamCornerstone");

	Params::FortTeamInfoPvPBaseDestruction_GetTeamCornerstone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.OnClientDeselect
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnClientDeselect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnClientDeselect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnClientSelect
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnClientSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnClientSelect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnDefocus
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnDefocus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnDefocus");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnDeselectWrapper
// (Native, Public)
// Parameters:
// bool                                    bIsGameSessionOwner                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTheaterMapTile::OnDeselectWrapper(bool bIsGameSessionOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnDeselectWrapper");

	Params::FortTheaterMapTile_OnDeselectWrapper Parms{};

	Parms.bIsGameSessionOwner = bIsGameSessionOwner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTheaterMapTile.OnDisableGoToPrompt
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnDisableGoToPrompt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnDisableGoToPrompt");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnEnableGoToPrompt
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnEnableGoToPrompt()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnEnableGoToPrompt");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnFocus
// (BlueprintCosmetic, Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnFocus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnFocus");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnHostDeselect
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnHostDeselect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnHostDeselect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnHostSelect
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnHostSelect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnHostSelect");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnInitializeTile
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnInitializeTile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnInitializeTile");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnMissionDataUpdated
// (Event, Public, BlueprintEvent)

void AFortTheaterMapTile::OnMissionDataUpdated()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnMissionDataUpdated");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortTheaterMapTile.OnMouseOverBegin
// (Final, Native, Public)

void AFortTheaterMapTile::OnMouseOverBegin()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnMouseOverBegin");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTheaterMapTile.OnMouseOverEnd
// (Final, Native, Public)

void AFortTheaterMapTile::OnMouseOverEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnMouseOverEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTheaterMapTile.OnSelectWrapper
// (Native, Public)
// Parameters:
// bool                                    bIsGameSessionOwner                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTheaterMapTile::OnSelectWrapper(bool bIsGameSessionOwner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnSelectWrapper");

	Params::FortTheaterMapTile_OnSelectWrapper Parms{};

	Parms.bIsGameSessionOwner = bIsGameSessionOwner;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTheaterMapTile.OnTileClicked
// (Final, Native, Public)

void AFortTheaterMapTile::OnTileClicked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "OnTileClicked");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTheaterMapTile.GetZoneDifficulty
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FGameDifficultyInfo              ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGameDifficultyInfo AFortTheaterMapTile::GetZoneDifficulty() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "GetZoneDifficulty");

	Params::FortTheaterMapTile_GetZoneDifficulty Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.HasValidMissionData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTheaterMapTile::HasValidMissionData() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "HasValidMissionData");

	Params::FortTheaterMapTile_HasValidMissionData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.IsTileHidden
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTheaterMapTile::IsTileHidden() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "IsTileHidden");

	Params::FortTheaterMapTile_IsTileHidden Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.IsTileLocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTheaterMapTile::IsTileLocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "IsTileLocked");

	Params::FortTheaterMapTile_IsTileLocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.IsTilePlayable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTheaterMapTile::IsTilePlayable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "IsTilePlayable");

	Params::FortTheaterMapTile_IsTilePlayable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTheaterMapTile.IsTileSelectable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AFortTheaterMapTile::IsTileSelectable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTheaterMapTile", "IsTileSelectable");

	Params::FortTheaterMapTile_IsTileSelectable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortThreatParticleActor.OnThreatCloudsChanged
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<struct FThreatLocationInfo>&ThreatLocationInfo                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AFortThreatParticleActor::OnThreatCloudsChanged(const TArray<struct FThreatLocationInfo>& ThreatLocationInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatParticleActor", "OnThreatCloudsChanged");

	Params::FortThreatParticleActor_OnThreatCloudsChanged Parms{};

	Parms.ThreatLocationInfo = std::move(ThreatLocationInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortThreatParticleActor.GetThreatClouds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FThreatLocationInfo>      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FThreatLocationInfo> AFortThreatParticleActor::GetThreatClouds() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortThreatParticleActor", "GetThreatClouds");

	Params::FortThreatParticleActor_GetThreatClouds Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbilityTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbilityTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbilityTooltip", "GetTextForToken");

	Params::FortGameplayAbilityTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbilityTooltip.GetTextForTokenFromAbilitySpec
// (Final, Native, Protected, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayAbilitySpec&      Spec                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbilityTooltip::GetTextForTokenFromAbilitySpec(const struct FGameplayAbilitySpec& Spec, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbilityTooltip", "GetTextForTokenFromAbilitySpec");

	Params::FortGameplayAbilityTooltip_GetTextForTokenFromAbilitySpec Parms{};

	Parms.Spec = std::move(Spec);
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbilityTooltip.GetTextForTokenFromAbilitySpecInternal
// (Native, Event, Protected, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const struct FGameplayAbilitySpec&      Spec                                                   (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbilityTooltip::GetTextForTokenFromAbilitySpecInternal(const struct FGameplayAbilitySpec& Spec, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbilityTooltip", "GetTextForTokenFromAbilitySpecInternal");

	Params::FortGameplayAbilityTooltip_GetTextForTokenFromAbilitySpecInternal Parms{};

	Parms.Spec = std::move(Spec);
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGameplayAbilityTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGameplayAbilityTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGameplayAbilityTooltip", "GetTokenizedDescriptionText");

	Params::FortGameplayAbilityTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGadgetItemDefinitionTooltip.GetTextForToken
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      Token                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutText                                                (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGadgetItemDefinitionTooltip::GetTextForToken(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, const class FName& Token, class FText* OutText) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGadgetItemDefinitionTooltip", "GetTextForToken");

	Params::FortGadgetItemDefinitionTooltip_GetTextForToken Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;
	Parms.Token = Token;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutText != nullptr)
		*OutText = std::move(Parms.OutText);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortGadgetItemDefinitionTooltip.GetTokenizedDescriptionText
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    ObjectToDescribe                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTag&              Tag                                                    (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const class UFortTooltipContext*        Context                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText*                            OutDescription                                         (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool UFortGadgetItemDefinitionTooltip::GetTokenizedDescriptionText(const class UObject* ObjectToDescribe, const struct FGameplayTag& Tag, const class UFortTooltipContext* Context, class FText* OutDescription) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortGadgetItemDefinitionTooltip", "GetTokenizedDescriptionText");

	Params::FortGadgetItemDefinitionTooltip_GetTokenizedDescriptionText Parms{};

	Parms.ObjectToDescribe = ObjectToDescribe;
	Parms.Tag = std::move(Tag);
	Parms.Context = Context;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutDescription != nullptr)
		*OutDescription = std::move(Parms.OutDescription);

	return Parms.ReturnValue;
}


// Function FortniteGame.FortTracerBase.Init
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Start                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FVector&                   End                                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AFortTracerBase::Init(const struct FVector& Start, const struct FVector& End)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTracerBase", "Init");

	Params::FortTracerBase_Init Parms{};

	Parms.Start = std::move(Start);
	Parms.End = std::move(End);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortTracerBase.OnInitTracerDistance
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   Distance                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortTracerBase::OnInitTracerDistance(float Distance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTracerBase", "OnInitTracerDistance");

	Params::FortTracerBase_OnInitTracerDistance Parms{};

	Parms.Distance = Distance;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortTracerBase.OnRep_TracerDistance
// (Final, Native, Private)

void AFortTracerBase::OnRep_TracerDistance()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortTracerBase", "OnRep_TracerDistance");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortUIManagerInterface.KillConfirmation
// (Event, Public, BlueprintEvent)

void IFortUIManagerInterface::KillConfirmation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortUIManagerInterface", "KillConfirmation");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortMiniMapComponent.OnRep_MiniMapData
// (Final, Native, Private)

void UFortMiniMapComponent::OnRep_MiniMapData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "OnRep_MiniMapData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIcon
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       MiniMapIcon                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIcon(class UTexture2D* MiniMapIcon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIcon");

	Params::FortMiniMapComponent_SetMiniMapIcon Parms{};

	Parms.MiniMapIcon = MiniMapIcon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIconColor
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              InColor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIconColor(const struct FLinearColor& InColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIconColor");

	Params::FortMiniMapComponent_SetMiniMapIconColor Parms{};

	Parms.InColor = std::move(InColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIconColorPulsesPerSecond
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ColorPulsesPerSecond                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIconColorPulsesPerSecond(float ColorPulsesPerSecond)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIconColorPulsesPerSecond");

	Params::FortMiniMapComponent_SetMiniMapIconColorPulsesPerSecond Parms{};

	Parms.ColorPulsesPerSecond = ColorPulsesPerSecond;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIconPulseColor
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FLinearColor&              PulseColor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIconPulseColor(const struct FLinearColor& PulseColor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIconPulseColor");

	Params::FortMiniMapComponent_SetMiniMapIconPulseColor Parms{};

	Parms.PulseColor = std::move(PulseColor);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIconSizePulsesPerSecond
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   SizePulsesPerSecond                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIconSizePulsesPerSecond(float SizePulsesPerSecond)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIconSizePulsesPerSecond");

	Params::FortMiniMapComponent_SetMiniMapIconSizePulsesPerSecond Parms{};

	Parms.SizePulsesPerSecond = SizePulsesPerSecond;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapIndicatorIsVisible
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVisible                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapIndicatorIsVisible(bool bVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapIndicatorIsVisible");

	Params::FortMiniMapComponent_SetMiniMapIndicatorIsVisible Parms{};

	Parms.bVisible = bVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetMiniMapViewableDistance
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ViewDistance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetMiniMapViewableDistance(float ViewDistance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetMiniMapViewableDistance");

	Params::FortMiniMapComponent_SetMiniMapViewableDistance Parms{};

	Parms.ViewDistance = ViewDistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortMiniMapComponent.SetupMiniMapComponent
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UTexture2D*                       MiniMapIcon                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLinearColor&              IconColor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLinearColor&              PulseColor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ColorPulsesPerSecond                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SizePulsesPerSecond                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UFortMiniMapComponent::SetupMiniMapComponent(class UTexture2D* MiniMapIcon, const struct FLinearColor& IconColor, const struct FLinearColor& PulseColor, float ColorPulsesPerSecond, float SizePulsesPerSecond)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortMiniMapComponent", "SetupMiniMapComponent");

	Params::FortMiniMapComponent_SetupMiniMapComponent Parms{};

	Parms.MiniMapIcon = MiniMapIcon;
	Parms.IconColor = std::move(IconColor);
	Parms.PulseColor = std::move(PulseColor);
	Parms.ColorPulsesPerSecond = ColorPulsesPerSecond;
	Parms.SizePulsesPerSecond = SizePulsesPerSecond;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPOnEquip
// (Event, Public, BlueprintEvent)
// Parameters:
// class AFortWeapon*                      OldWeapon                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPOnEquip(class AFortWeapon* OldWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPOnEquip");

	Params::FortCustomizableAbilityDecoTool_BPOnEquip Parms{};

	Parms.OldWeapon = OldWeapon;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPOnSetDecoObjectPreview
// (Event, Public, BlueprintEvent)
// Parameters:
// class AFortDecoHelper*                  FortDecoHelper                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPOnSetDecoObjectPreview(class AFortDecoHelper* FortDecoHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPOnSetDecoObjectPreview");

	Params::FortCustomizableAbilityDecoTool_BPOnSetDecoObjectPreview Parms{};

	Parms.FortDecoHelper = FortDecoHelper;

	UObject::ProcessEvent(Func, &Parms);
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPOnUnEquip
// (Event, Public, BlueprintEvent)

void AFortCustomizableAbilityDecoTool::BPOnUnEquip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPOnUnEquip");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPPressSecondaryFire
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AFortDecoHelper*                  FortDecoHelper                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPPressSecondaryFire(class AFortDecoHelper* FortDecoHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPPressSecondaryFire");

	Params::FortCustomizableAbilityDecoTool_BPPressSecondaryFire Parms{};

	Parms.FortDecoHelper = FortDecoHelper;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPPressTrigger
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AFortDecoHelper*                  FortDecoHelper                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPPressTrigger(class AFortDecoHelper* FortDecoHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPPressTrigger");

	Params::FortCustomizableAbilityDecoTool_BPPressTrigger Parms{};

	Parms.FortDecoHelper = FortDecoHelper;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPReleaseSecondaryFire
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AFortDecoHelper*                  FortDecoHelper                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPReleaseSecondaryFire(class AFortDecoHelper* FortDecoHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPReleaseSecondaryFire");

	Params::FortCustomizableAbilityDecoTool_BPReleaseSecondaryFire Parms{};

	Parms.FortDecoHelper = FortDecoHelper;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPReleaseTrigger
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AFortDecoHelper*                  FortDecoHelper                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AFortCustomizableAbilityDecoTool::BPReleaseTrigger(class AFortDecoHelper* FortDecoHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPReleaseTrigger");

	Params::FortCustomizableAbilityDecoTool_BPReleaseTrigger Parms{};

	Parms.FortDecoHelper = FortDecoHelper;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPServerPressSecondaryFire
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortCustomizableAbilityDecoTool::BPServerPressSecondaryFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPServerPressSecondaryFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.BPServerReleaseSecondaryFire
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)

void AFortCustomizableAbilityDecoTool::BPServerReleaseSecondaryFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "BPServerReleaseSecondaryFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.ServerPressSecondaryFire
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortCustomizableAbilityDecoTool::ServerPressSecondaryFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "ServerPressSecondaryFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.ServerPressTrigger
// (BlueprintCosmetic, Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void AFortCustomizableAbilityDecoTool::ServerPressTrigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "ServerPressTrigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.ServerReleaseSecondaryFire
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AFortCustomizableAbilityDecoTool::ServerReleaseSecondaryFire()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "ServerReleaseSecondaryFire");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortCustomizableAbilityDecoTool.ServerReleaseTrigger
// (BlueprintCosmetic, Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void AFortCustomizableAbilityDecoTool::ServerReleaseTrigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortCustomizableAbilityDecoTool", "ServerReleaseTrigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.FortWeap_EditingTool.OnRep_EditActor
// (Final, Native, Private)

void AFortWeap_EditingTool::OnRep_EditActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("FortWeap_EditingTool", "OnRep_EditActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseWorker.GetWorkerItem
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UFortWorker*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UFortWorker* UHomeBaseWorker::GetWorkerItem() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseWorker", "GetWorkerItem");

	Params::HomeBaseWorker_GetWorkerItem Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.HomeBaseCommandCenterBuilding.CollectProducedResources
// (Final, Native, Public, BlueprintCallable)

void UHomeBaseCommandCenterBuilding::CollectProducedResources()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseCommandCenterBuilding", "CollectProducedResources");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.HomeBaseCommandCenterBuilding.GetProducedResources
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FHomeBaseProducedResources>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FHomeBaseProducedResources> UHomeBaseCommandCenterBuilding::GetProducedResources() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("HomeBaseCommandCenterBuilding", "GetProducedResources");

	Params::HomeBaseCommandCenterBuilding_GetProducedResources Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.LevelTestingActorBase.ExtractSkeletalMesh
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TSubclassOf<class AActor>               BlueprintClass                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USkeletalMesh*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class USkeletalMesh* ALevelTestingActorBase::ExtractSkeletalMesh(TSubclassOf<class AActor> BlueprintClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LevelTestingActorBase", "ExtractSkeletalMesh");

	Params::LevelTestingActorBase_ExtractSkeletalMesh Parms{};

	Parms.BlueprintClass = BlueprintClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.LevelTestingActorBase.ExtractSkeletalMeshScale
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// TSubclassOf<class AActor>               BlueprintClass                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FVector ALevelTestingActorBase::ExtractSkeletalMeshScale(TSubclassOf<class AActor> BlueprintClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LevelTestingActorBase", "ExtractSkeletalMeshScale");

	Params::LevelTestingActorBase_ExtractSkeletalMeshScale Parms{};

	Parms.BlueprintClass = BlueprintClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorPortal.BlueprintOnUnlockPortalComplete
// (Event, Public, BlueprintEvent)

void AManorPortal::BlueprintOnUnlockPortalComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "BlueprintOnUnlockPortalComplete");

	UObject::ProcessEvent(Func, nullptr);
}


// Function FortniteGame.ManorPortal.GetCurrencyCost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AManorPortal::GetCurrencyCost(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "GetCurrencyCost");

	Params::ManorPortal_GetCurrencyCost Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorPortal.GetPlayerCurrencyAmount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AManorPortal::GetPlayerCurrencyAmount(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "GetPlayerCurrencyAmount");

	Params::ManorPortal_GetPlayerCurrencyAmount Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorPortal.IsPortalUnlocked
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AManorPortal::IsPortalUnlocked(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "IsPortalUnlocked");

	Params::ManorPortal_IsPortalUnlocked Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorPortal.IsProfileValidToReadPortalAvailability
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

bool AManorPortal::IsProfileValidToReadPortalAvailability(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "IsProfileValidToReadPortalAvailability");

	Params::ManorPortal_IsProfileValidToReadPortalAvailability Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function FortniteGame.ManorPortal.OpenUnlockMenu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AManorPortal::OpenUnlockMenu(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "OpenUnlockMenu");

	Params::ManorPortal_OpenUnlockMenu Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function FortniteGame.ManorPortal.UnlockPortal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AFortPlayerController*            Player                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AManorPortal::UnlockPortal(class AFortPlayerController* Player)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ManorPortal", "UnlockPortal");

	Params::ManorPortal_UnlockPortal Parms{};

	Parms.Player = Player;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}

}

#pragma pack(pop)