//PUBGM(0.13.5)32位SDK
//作者:清华
//Telegram:@qinghuanb666
//生成时间:Fri Apr 18 20:44:39 2025

#include "../SDK.hpp"

namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------

// Function ShadowTrackerExtra.ActorCacheMgr.GetActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                  Type                           (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* AActorCacheMgr::GetActor(class UClass* Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ActorCacheMgr.GetActor");

	AActorCacheMgr_GetActor_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ActorCacheMgr.AddToPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                  Type                           (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AActorCacheMgr::AddToPool(class UClass* Type, class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ActorCacheMgr.AddToPool");

	AActorCacheMgr_AddToPool_Params params;
	params.Type = Type;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AIActingComponent.BroadFinishLastBreathFunction
// (Final, Native, Public)
// Parameters:
// struct FString                 Killer                         (Parm, ZeroConstructor)
// struct FString                 Killed                         (Parm, ZeroConstructor)
// int                            WeaponID                       (Parm, ZeroConstructor, IsPlainOldData)

void UAIActingComponent::BroadFinishLastBreathFunction(const struct FString& Killer, const struct FString& Killed, int WeaponID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AIActingComponent.BroadFinishLastBreathFunction");

	UAIActingComponent_BroadFinishLastBreathFunction_Params params;
	params.Killer = Killer;
	params.Killed = Killed;
	params.WeaponID = WeaponID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AIActingComponent.AdjustPosIsInDeliveryLimitArea
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 pos                            (Parm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAIActingComponent::AdjustPosIsInDeliveryLimitArea(const struct FVector& pos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AIActingComponent.AdjustPosIsInDeliveryLimitArea");

	UAIActingComponent_AdjustPosIsInDeliveryLimitArea_Params params;
	params.pos = pos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirAttackCS.OnAirAttack
// (Final, Native, Protected)
// Parameters:
// TEnumAsByte<EAirAttackInfo>    airattacktype                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            waveindex                      (Parm, ZeroConstructor, IsPlainOldData)

void UAirAttackCS::OnAirAttack(TEnumAsByte<EAirAttackInfo> airattacktype, int waveindex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirAttackCS.OnAirAttack");

	UAirAttackCS_OnAirAttack_Params params;
	params.airattacktype = airattacktype;
	params.waveindex = waveindex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirAttackCS.DoBombHarmAtLocation
// (Final, Native, Private, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 bombLocation                   (Parm, OutParm, IsPlainOldData)

void UAirAttackCS::DoBombHarmAtLocation(struct FVector* bombLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirAttackCS.DoBombHarmAtLocation");

	UAirAttackCS_DoBombHarmAtLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (bombLocation != nullptr)
		*bombLocation = params.bombLocation;
}


// Function ShadowTrackerExtra.AirAttackCS.AirAttackThrowBomb
// (Final, Native, Private)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UAirAttackCS::AirAttackThrowBomb(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirAttackCS.AirAttackThrowBomb");

	UAirAttackCS_AirAttackThrowBomb_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.StartAsyncLoadBoxAppearanceResource
// (Final, Native, Protected)

void AAirDropBoxActor::StartAsyncLoadBoxAppearanceResource()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.StartAsyncLoadBoxAppearanceResource");

	AAirDropBoxActor_StartAsyncLoadBoxAppearanceResource_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.SetBuoyancyUpdatedComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*         UpdatedComponent               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AAirDropBoxActor::SetBuoyancyUpdatedComponent(class USceneComponent* UpdatedComponent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.SetBuoyancyUpdatedComponent");

	AAirDropBoxActor_SetBuoyancyUpdatedComponent_Params params;
	params.UpdatedComponent = UpdatedComponent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.OnRep_SpecialTypeChange
// (Final, Native, Public)

void AAirDropBoxActor::OnRep_SpecialTypeChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.OnRep_SpecialTypeChange");

	AAirDropBoxActor_OnRep_SpecialTypeChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.OnRep_BoxId
// (Final, Native, Public)

void AAirDropBoxActor::OnRep_BoxId()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.OnRep_BoxId");

	AAirDropBoxActor_OnRep_BoxId_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.OnRep_AirdropTypeChange
// (Final, Native, Public)

void AAirDropBoxActor::OnRep_AirdropTypeChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.OnRep_AirdropTypeChange");

	AAirDropBoxActor_OnRep_AirdropTypeChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.OnBoxDropIntoWater
// (Event, Public, BlueprintEvent)

void AAirDropBoxActor::OnBoxDropIntoWater()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.OnBoxDropIntoWater");

	AAirDropBoxActor_OnBoxDropIntoWater_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.OnAsyncLoadingBoxAppearanceResourceFinished
// (Final, Native, Protected)
// Parameters:
// TArray<struct FSoftObjectPath> ResPaths                       (Parm, ZeroConstructor)

void AAirDropBoxActor::OnAsyncLoadingBoxAppearanceResourceFinished(TArray<struct FSoftObjectPath> ResPaths)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.OnAsyncLoadingBoxAppearanceResourceFinished");

	AAirDropBoxActor_OnAsyncLoadingBoxAppearanceResourceFinished_Params params;
	params.ResPaths = ResPaths;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.IsDropIntoWater
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          SphereRadius                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AAirDropBoxActor::IsDropIntoWater(float SphereRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.IsDropIntoWater");

	AAirDropBoxActor_IsDropIntoWater_Params params;
	params.SphereRadius = SphereRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirDropBoxActor.GenerateWrappersBox
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<struct FAirDropBoxGenerateWrapperItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 BoxLoc                         (Parm, IsPlainOldData)

void AAirDropBoxActor::GenerateWrappersBox(TArray<struct FAirDropBoxGenerateWrapperItemData> DataList, const struct FVector& BoxLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.GenerateWrappersBox");

	AAirDropBoxActor_GenerateWrappersBox_Params params;
	params.DataList = DataList;
	params.BoxLoc = BoxLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.ForceUpdateAirdropLoc
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AAirDropBoxActor::ForceUpdateAirdropLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.ForceUpdateAirdropLoc");

	AAirDropBoxActor_ForceUpdateAirdropLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirDropBoxActor.DistanceScalerChangedEvent
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Scale                          (Parm, ZeroConstructor, IsPlainOldData)

void AAirDropBoxActor::DistanceScalerChangedEvent(float Scale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.DistanceScalerChangedEvent");

	AAirDropBoxActor_DistanceScalerChangedEvent_Params params;
	params.Scale = Scale;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.ChangeAirdropAppearance
// (Event, Public, BlueprintEvent)

void AAirDropBoxActor::ChangeAirdropAppearance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.ChangeAirdropAppearance");

	AAirDropBoxActor_ChangeAirdropAppearance_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.BoxReachGround
// (Event, Public, BlueprintEvent)

void AAirDropBoxActor::BoxReachGround()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.BoxReachGround");

	AAirDropBoxActor_BoxReachGround_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropBoxActor.AddToAIList
// (Final, Native, Public, BlueprintCallable)

void AAirDropBoxActor::AddToAIList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropBoxActor.AddToAIList");

	AAirDropBoxActor_AddToAIList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DropVehicleStrategy.Apply
// (Native, Public)
// Parameters:
// class AAirDropPlane*           Plane                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDropVehicleStrategy::Apply(class AAirDropPlane* Plane)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DropVehicleStrategy.Apply");

	UDropVehicleStrategy_Apply_Params params;
	params.Plane = Plane;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DropBoxStrategy.Apply
// (Native, Public)
// Parameters:
// class AAirDropPlane*           Plane                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDropBoxStrategy::Apply(class AAirDropPlane* Plane)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DropBoxStrategy.Apply");

	UDropBoxStrategy_Apply_Params params;
	params.Plane = Plane;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirDropComponent.OnAirDropStart
// (Final, Native, Private)
// Parameters:
// struct FAirDropOrder           Order                          (Parm)
// EAirDropType                   DropType                       (Parm, ZeroConstructor, IsPlainOldData)

void UAirDropComponent::OnAirDropStart(const struct FAirDropOrder& Order, EAirDropType DropType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropComponent.OnAirDropStart");

	UAirDropComponent_OnAirDropStart_Params params;
	params.Order = Order;
	params.DropType = DropType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropComponent.CallSuperAirDrop
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 DropLoc                        (Parm, IsPlainOldData)
// uint32_t                       SummonerKey                    (Parm, ZeroConstructor, IsPlainOldData)

void UAirDropComponent::CallSuperAirDrop(const struct FVector& DropLoc, uint32_t SummonerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropComponent.CallSuperAirDrop");

	UAirDropComponent_CallSuperAirDrop_Params params;
	params.DropLoc = DropLoc;
	params.SummonerKey = SummonerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropComponent.CallFlareGunAirDrop
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 InDropLoc                      (Parm, IsPlainOldData)
// EAirDropType                   DropType                       (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       SummonerKey                    (Parm, ZeroConstructor, IsPlainOldData)

void UAirDropComponent::CallFlareGunAirDrop(const struct FVector& InDropLoc, EAirDropType DropType, uint32_t SummonerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropComponent.CallFlareGunAirDrop");

	UAirDropComponent_CallFlareGunAirDrop_Params params;
	params.InDropLoc = InDropLoc;
	params.DropType = DropType;
	params.SummonerKey = SummonerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.ShowMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::ShowMesh(bool bShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.ShowMesh");

	APickUpWrapperActor_ShowMesh_Params params;
	params.bShow = bShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.ShowActor
// (Final, Native, Protected)

void APickUpWrapperActor::ShowActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.ShowActor");

	APickUpWrapperActor_ShowActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.SetDefineID
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DID                            (ConstParm, Parm, OutParm, ReferenceParm)

void APickUpWrapperActor::SetDefineID(const struct FItemDefineID& DID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.SetDefineID");

	APickUpWrapperActor_SetDefineID_Params params;
	params.DID = DID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.SetCountOnServerAfterSpawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            _Count                         (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::SetCountOnServerAfterSpawn(int _Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.SetCountOnServerAfterSpawn");

	APickUpWrapperActor_SetCountOnServerAfterSpawn_Params params;
	params._Count = _Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.SetActorToGround
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable, NetValidate)
// Parameters:
// class AActor*                  ignoreActor                    (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::SetActorToGround(class AActor* ignoreActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.SetActorToGround");

	APickUpWrapperActor_SetActorToGround_Params params;
	params.ignoreActor = ignoreActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.RPC_Broadcast_NotifyAllClientsModifySavedAdditionalDataList
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable, NetValidate)
// Parameters:
// TArray<struct FBattleItemAdditionalData> DataList                       (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void APickUpWrapperActor::RPC_Broadcast_NotifyAllClientsModifySavedAdditionalDataList(TArray<struct FBattleItemAdditionalData> DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.RPC_Broadcast_NotifyAllClientsModifySavedAdditionalDataList");

	APickUpWrapperActor_RPC_Broadcast_NotifyAllClientsModifySavedAdditionalDataList_Params params;
	params.DataList = DataList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.RPC_Broadcast_NotifyAllClientsHideActorForSomeTime
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable, NetValidate)
// Parameters:
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::RPC_Broadcast_NotifyAllClientsHideActorForSomeTime(float Time)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.RPC_Broadcast_NotifyAllClientsHideActorForSomeTime");

	APickUpWrapperActor_RPC_Broadcast_NotifyAllClientsHideActorForSomeTime_Params params;
	params.Time = Time;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.RegisterToPlayerPickUpList
// (Final, Native, Public, BlueprintCallable)

void APickUpWrapperActor::RegisterToPlayerPickUpList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.RegisterToPlayerPickUpList");

	APickUpWrapperActor_RegisterToPlayerPickUpList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_DropGroundEffectInfo
// (Final, Native, Protected)

void APickUpWrapperActor::OnRep_DropGroundEffectInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_DropGroundEffectInfo");

	APickUpWrapperActor_OnRep_DropGroundEffectInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_AttachmentReplication
// (Native, Public)

void APickUpWrapperActor::OnRep_AttachmentReplication()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_AttachmentReplication");

	APickUpWrapperActor_OnRep_AttachmentReplication_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_AttachedActor
// (Final, Native, Protected)

void APickUpWrapperActor::OnRep_AttachedActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.OnRep_AttachedActor");

	APickUpWrapperActor_OnRep_AttachedActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.ModifyData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            _Count                         (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::ModifyData(int _Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.ModifyData");

	APickUpWrapperActor_ModifyData_Params params;
	params._Count = _Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.MarkIsDropedByPlayerOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Ret                            (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DropOwner                      (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::MarkIsDropedByPlayerOnServer(bool Ret, class AActor* DropOwner)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.MarkIsDropedByPlayerOnServer");

	APickUpWrapperActor_MarkIsDropedByPlayerOnServer_Params params;
	params.Ret = Ret;
	params.DropOwner = DropOwner;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.InitData
// (Final, Native, Public)
// Parameters:
// class UItemSpotSceneComponent* Component                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            ItemCount                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Value                          (Parm, ZeroConstructor)
// struct FString                 Category                       (Parm, ZeroConstructor)
// bool                           RepeatGenerateItem             (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::InitData(class UItemSpotSceneComponent* Component, int ItemCount, const struct FString& Value, const struct FString& Category, bool RepeatGenerateItem)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.InitData");

	APickUpWrapperActor_InitData_Params params;
	params.Component = Component;
	params.ItemCount = ItemCount;
	params.Value = Value;
	params.Category = Category;
	params.RepeatGenerateItem = RepeatGenerateItem;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.GetNetGUIDOffsetValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int APickUpWrapperActor::GetNetGUIDOffsetValue()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.GetNetGUIDOffsetValue");

	APickUpWrapperActor_GetNetGUIDOffsetValue_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.GetDataList
// (Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FPickUpItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FPickUpItemData> APickUpWrapperActor::GetDataList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.GetDataList");

	APickUpWrapperActor_GetDataList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.ForceNetUpdate
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void APickUpWrapperActor::ForceNetUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.ForceNetUpdate");

	APickUpWrapperActor_ForceNetUpdate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.FinishPickedUp
// (Native, Protected)
// Parameters:
// class AActor*                  OwnerTarget                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::FinishPickedUp(class AActor* OwnerTarget, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.FinishPickedUp");

	APickUpWrapperActor_FinishPickedUp_Params params;
	params.OwnerTarget = OwnerTarget;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.CheckPickUpDataIsWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool APickUpWrapperActor::CheckPickUpDataIsWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.CheckPickUpDataIsWeapon");

	APickUpWrapperActor_CheckPickUpDataIsWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.BroadcastDataToAllClients
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable, NetValidate)
// Parameters:
// int                            Count_New                      (Parm, ZeroConstructor, IsPlainOldData)

void APickUpWrapperActor::BroadcastDataToAllClients(int Count_New)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.BroadcastDataToAllClients");

	APickUpWrapperActor_BroadcastDataToAllClients_Params params;
	params.Count_New = Count_New;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpWrapperActor.AddAdditionalDataListOnServerAfterSpawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FBattleItemAdditionalData> DataList                       (Parm, ZeroConstructor)

void APickUpWrapperActor::AddAdditionalDataListOnServerAfterSpawn(TArray<struct FBattleItemAdditionalData> DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpWrapperActor.AddAdditionalDataListOnServerAfterSpawn");

	APickUpWrapperActor_AddAdditionalDataListOnServerAfterSpawn_Params params;
	params.DataList = DataList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpListWrapperActor.RPC_Broadcast_NotifyAllClientsModifyCount
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable, NetValidate)
// Parameters:
// int                            ItemInstanceID                 (Parm, ZeroConstructor, IsPlainOldData)
// int                            RetCount                       (Parm, ZeroConstructor, IsPlainOldData)

void APickUpListWrapperActor::RPC_Broadcast_NotifyAllClientsModifyCount(int ItemInstanceID, int RetCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpListWrapperActor.RPC_Broadcast_NotifyAllClientsModifyCount");

	APickUpListWrapperActor_RPC_Broadcast_NotifyAllClientsModifyCount_Params params;
	params.ItemInstanceID = ItemInstanceID;
	params.RetCount = RetCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpListWrapperActor.RPC_Broadcast_ForceSyncAllData
// (Net, NetReliable, Native, Event, NetMulticast, Protected, BlueprintCallable, NetValidate)
// Parameters:
// TArray<struct FPickUpItemData> DataList                       (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void APickUpListWrapperActor::RPC_Broadcast_ForceSyncAllData(TArray<struct FPickUpItemData> DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpListWrapperActor.RPC_Broadcast_ForceSyncAllData");

	APickUpListWrapperActor_RPC_Broadcast_ForceSyncAllData_Params params;
	params.DataList = DataList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpListWrapperActor.OnRep_PickUpDataList
// (Final, Native, Protected)

void APickUpListWrapperActor::OnRep_PickUpDataList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpListWrapperActor.OnRep_PickUpDataList");

	APickUpListWrapperActor_OnRep_PickUpDataList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.PickUpListWrapperActor.OnBoxEmptyDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            boxId                          (Parm, ZeroConstructor, IsPlainOldData)

void APickUpListWrapperActor::OnBoxEmptyDelegate__DelegateSignature(int boxId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.PickUpListWrapperActor.OnBoxEmptyDelegate__DelegateSignature");

	APickUpListWrapperActor_OnBoxEmptyDelegate__DelegateSignature_Params params;
	params.boxId = boxId;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickUpListWrapperActor.GetDataList
// (Native, Public)
// Parameters:
// TArray<struct FPickUpItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FPickUpItemData> APickUpListWrapperActor::GetDataList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpListWrapperActor.GetDataList");

	APickUpListWrapperActor_GetDataList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickUpListWrapperActor.FinishPickedUp
// (Native, Protected)
// Parameters:
// class AActor*                  OwnerTarget                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void APickUpListWrapperActor::FinishPickedUp(class AActor* OwnerTarget, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickUpListWrapperActor.FinishPickedUp");

	APickUpListWrapperActor_FinishPickedUp_Params params;
	params.OwnerTarget = OwnerTarget;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropPlane.SetDropStrategy
// (Final, Native, Public)
// Parameters:
// class UDropStuffStrategy*      Strategy                       (Parm, ZeroConstructor, IsPlainOldData)

void AAirDropPlane::SetDropStrategy(class UDropStuffStrategy* Strategy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropPlane.SetDropStrategy");

	AAirDropPlane_SetDropStrategy_Params params;
	params.Strategy = Strategy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropPlane.OnRep_FlyingParams
// (Final, Native, Public)

void AAirDropPlane::OnRep_FlyingParams()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropPlane.OnRep_FlyingParams");

	AAirDropPlane_OnRep_FlyingParams_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AirDropPlane.GetDropStrategyArray
// (Final, Native, Public)
// Parameters:
// TArray<class UDropStuffStrategy*> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class UDropStuffStrategy*> AAirDropPlane::GetDropStrategyArray()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropPlane.GetDropStrategyArray");

	AAirDropPlane_GetDropStrategyArray_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirDropPlane.GetDropStrategy
// (Final, Native, Public)
// Parameters:
// class UDropStuffStrategy*      ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UDropStuffStrategy* AAirDropPlane::GetDropStrategy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropPlane.GetDropStrategy");

	AAirDropPlane_GetDropStrategy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AirDropPlane.GetDroppingIndex
// (Final, Native, Private)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AAirDropPlane::GetDroppingIndex(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AirDropPlane.GetDroppingIndex");

	AAirDropPlane_GetDroppingIndex_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AnchorFlagWidget.SetBaseCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   BC                             (Parm, ZeroConstructor, IsPlainOldData)

void UAnchorFlagWidget::SetBaseCharacter(class ASTExtraBaseCharacter* BC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AnchorFlagWidget.SetBaseCharacter");

	UAnchorFlagWidget_SetBaseCharacter_Params params;
	params.BC = BC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.Tick
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::Tick(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.Tick");

	UATTaskGraph_Tick_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.RemoveTaskNode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::RemoveTaskNode(class UATTaskNodeBase* Node)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.RemoveTaskNode");

	UATTaskGraph_RemoveTaskNode_Params params;
	params.Node = Node;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.ReceiveTick
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::ReceiveTick(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.ReceiveTick");

	UATTaskGraph_ReceiveTick_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.ReceiveEndGraph
// (Native, Event, Protected, BlueprintEvent)

void UATTaskGraph::ReceiveEndGraph()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.ReceiveEndGraph");

	UATTaskGraph_ReceiveEndGraph_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.ReceiveBeginGraph
// (Native, Event, Protected, BlueprintEvent)

void UATTaskGraph::ReceiveBeginGraph()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.ReceiveBeginGraph");

	UATTaskGraph_ReceiveBeginGraph_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.ProcessTask
// (Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskNodeBase*         Task                           (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::ProcessTask(class UATTaskNodeBase* Task)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.ProcessTask");

	UATTaskGraph_ProcessTask_Params params;
	params.Task = Task;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.EndGraph
// (Native, Public, BlueprintCallable)

void UATTaskGraph::EndGraph()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.EndGraph");

	UATTaskGraph_EndGraph_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.ChangeState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EATTaskGraphState              NewState                       (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::ChangeState(EATTaskGraphState NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.ChangeState");

	UATTaskGraph_ChangeState_Params params;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.BeginGraph
// (Native, Public, BlueprintCallable)

void UATTaskGraph::BeginGraph()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.BeginGraph");

	UATTaskGraph_BeginGraph_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph.AddTaskNode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskGraph::AddTaskNode(class UATTaskNodeBase* Node)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph.AddTaskNode");

	UATTaskGraph_AddTaskNode_Params params;
	params.Node = Node;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph_DoorTest.NodeCallbackCheck
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskGraph_DoorTest::NodeCallbackCheck(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph_DoorTest.NodeCallbackCheck");

	UATTaskGraph_DoorTest_NodeCallbackCheck_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph_DoorTest.GetCurrentInfo
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UATTaskGraph_DoorTest::GetCurrentInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph_DoorTest.GetCurrentInfo");

	UATTaskGraph_DoorTest_GetCurrentInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ATTaskGraph_DoorTest.DelayEndFinished
// (Final, Native, Protected)

void UATTaskGraph_DoorTest::DelayEndFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph_DoorTest.DelayEndFinished");

	UATTaskGraph_DoorTest_DelayEndFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskGraph_DoorTest.BlockTestEndFinished
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskGraph_DoorTest::BlockTestEndFinished(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskGraph_DoorTest.BlockTestEndFinished");

	UATTaskGraph_DoorTest_BlockTestEndFinished_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.TickTask
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskNodeBase::TickTask(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.TickTask");

	UATTaskNodeBase_TickTask_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveTickTask
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskNodeBase::ReceiveTickTask(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveTickTask");

	UATTaskNodeBase_ReceiveTickTask_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveEndTask
// (Native, Event, Protected, BlueprintEvent)

void UATTaskNodeBase::ReceiveEndTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveEndTask");

	UATTaskNodeBase_ReceiveEndTask_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveBeginTask
// (Native, Event, Protected, BlueprintEvent)

void UATTaskNodeBase::ReceiveBeginTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.ReceiveBeginTask");

	UATTaskNodeBase_ReceiveBeginTask_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.ATTaskNodeBase.OnNodeStateChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeState               OldState                       (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeState               NewState                       (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskNodeBase::OnNodeStateChangeDelegate__DelegateSignature(class UATTaskNodeBase* Node, EATTaskNodeState OldState, EATTaskNodeState NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.ATTaskNodeBase.OnNodeStateChangeDelegate__DelegateSignature");

	UATTaskNodeBase_OnNodeStateChangeDelegate__DelegateSignature_Params params;
	params.Node = Node;
	params.OldState = OldState;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.ATTaskNodeBase.OnNodeExcuteResultDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskNodeBase::OnNodeExcuteResultDelegate__DelegateSignature(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.ATTaskNodeBase.OnNodeExcuteResultDelegate__DelegateSignature");

	UATTaskNodeBase_OnNodeExcuteResultDelegate__DelegateSignature_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.GetDescription
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UATTaskNodeBase::GetDescription()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.GetDescription");

	UATTaskNodeBase_GetDescription_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.ForceEndTask
// (Final, Native, Public, BlueprintCallable)

void UATTaskNodeBase::ForceEndTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.ForceEndTask");

	UATTaskNodeBase_ForceEndTask_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.EndTask
// (Native, Public, BlueprintCallable)

void UATTaskNodeBase::EndTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.EndTask");

	UATTaskNodeBase_EndTask_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.ChangeState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EATTaskNodeState               NewState                       (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskNodeBase::ChangeState(EATTaskNodeState NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.ChangeState");

	UATTaskNodeBase_ChangeState_Params params;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNodeBase.BeginTask
// (Native, Public, BlueprintCallable)

void UATTaskNodeBase::BeginTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNodeBase.BeginTask");

	UATTaskNodeBase_BeginTask_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_DelayTime.DelayTimeEnd
// (Final, Native, Protected)

void UATTaskNode_DelayTime::DelayTimeEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_DelayTime.DelayTimeEnd");

	UATTaskNode_DelayTime_DelayTimeEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_MoveAndTestBlock.TestBlockFinished
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskNode_MoveAndTestBlock::TestBlockFinished(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_MoveAndTestBlock.TestBlockFinished");

	UATTaskNode_MoveAndTestBlock_TestBlockFinished_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_MoveAndTestDoor.TestDoorFinished
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskNode_MoveAndTestDoor::TestDoorFinished(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_MoveAndTestDoor.TestDoorFinished");

	UATTaskNode_MoveAndTestDoor_TestDoorFinished_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_TestAroundDoors.TestAroundDoorsFinished
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskNode_TestAroundDoors::TestAroundDoorsFinished(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_TestAroundDoors.TestAroundDoorsFinished");

	UATTaskNode_TestAroundDoors_TestAroundDoorsFinished_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_TestAroundDoors.NodeCallbackCheck
// (Final, Native, Protected)
// Parameters:
// class UATTaskNodeBase*         Node                           (Parm, ZeroConstructor, IsPlainOldData)
// EATTaskNodeExcuteResult        Result                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ResultMsg                      (Parm, ZeroConstructor)

void UATTaskNode_TestAroundDoors::NodeCallbackCheck(class UATTaskNodeBase* Node, EATTaskNodeExcuteResult Result, const struct FString& ResultMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_TestAroundDoors.NodeCallbackCheck");

	UATTaskNode_TestAroundDoors_NodeCallbackCheck_Params params;
	params.Node = Node;
	params.Result = Result;
	params.ResultMsg = ResultMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_ToggleDoor.WaitDoorAnimEnd
// (Final, Native, Protected)

void UATTaskNode_ToggleDoor::WaitDoorAnimEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_ToggleDoor.WaitDoorAnimEnd");

	UATTaskNode_ToggleDoor_WaitDoorAnimEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ATTaskNode_ToggleDoor.HandleDoorAnimFinish
// (Final, Native, Protected)
// Parameters:
// class APUBGDoor*               door                           (Parm, ZeroConstructor, IsPlainOldData)

void UATTaskNode_ToggleDoor::HandleDoorAnimFinish(class APUBGDoor* door)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ATTaskNode_ToggleDoor.HandleDoorAnimFinish");

	UATTaskNode_ToggleDoor_HandleDoorAnimFinish_Params params;
	params.door = door;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AttrModifyProbeComponent.SetCharacterOverrideAttrValue
// (Final, Native, Public)
// Parameters:
// struct FString                 AttrName                       (Parm, ZeroConstructor)
// float                          AttrValue                      (Parm, ZeroConstructor, IsPlainOldData)

void UAttrModifyProbeComponent::SetCharacterOverrideAttrValue(const struct FString& AttrName, float AttrValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AttrModifyProbeComponent.SetCharacterOverrideAttrValue");

	UAttrModifyProbeComponent_SetCharacterOverrideAttrValue_Params params;
	params.AttrName = AttrName;
	params.AttrValue = AttrValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AttrModifyProbeComponent.RemoveDynamicModifier
// (Final, Native, Public)
// Parameters:
// class ASTExtraBaseCharacter*   STCharacter                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 AttrModifyItemName             (Parm, ZeroConstructor)

void UAttrModifyProbeComponent::RemoveDynamicModifier(class ASTExtraBaseCharacter* STCharacter, const struct FString& AttrModifyItemName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AttrModifyProbeComponent.RemoveDynamicModifier");

	UAttrModifyProbeComponent_RemoveDynamicModifier_Params params;
	params.STCharacter = STCharacter;
	params.AttrModifyItemName = AttrModifyItemName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AttrModifyProbeComponent.EnableGameModeOverrideAttrs
// (Final, Native, Public)
// Parameters:
// class ASTExtraBaseCharacter*   STCharacter                    (Parm, ZeroConstructor, IsPlainOldData)

void UAttrModifyProbeComponent::EnableGameModeOverrideAttrs(class ASTExtraBaseCharacter* STCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AttrModifyProbeComponent.EnableGameModeOverrideAttrs");

	UAttrModifyProbeComponent_EnableGameModeOverrideAttrs_Params params;
	params.STCharacter = STCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AttrModifyProbeComponent.AddDynamicModifier
// (Final, Native, Public)
// Parameters:
// class ASTExtraBaseCharacter*   STCharacter                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 AttrModifyItemName             (Parm, ZeroConstructor)
// float                          AttrValue                      (Parm, ZeroConstructor, IsPlainOldData)

void UAttrModifyProbeComponent::AddDynamicModifier(class ASTExtraBaseCharacter* STCharacter, const struct FString& AttrModifyItemName, float AttrValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AttrModifyProbeComponent.AddDynamicModifier");

	UAttrModifyProbeComponent_AddDynamicModifier_Params params;
	params.STCharacter = STCharacter;
	params.AttrModifyItemName = AttrModifyItemName;
	params.AttrValue = AttrValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AutoTestInterface.StarJumpPlane
// (Final, Native, Public)

void UAutoTestInterface::StarJumpPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestInterface.StarJumpPlane");

	UAutoTestInterface_StarJumpPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AutoTestSystemComponent.StopExistGraph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            GraphIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAutoTestSystemComponent::StopExistGraph(int GraphIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestSystemComponent.StopExistGraph");

	UAutoTestSystemComponent_StopExistGraph_Params params;
	params.GraphIndex = GraphIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AutoTestSystemComponent.StartNewGraph
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            GraphIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FTaskGraphInitParam     Param                          (Parm, OutParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAutoTestSystemComponent::StartNewGraph(int GraphIndex, struct FTaskGraphInitParam* Param)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestSystemComponent.StartNewGraph");

	UAutoTestSystemComponent_StartNewGraph_Params params;
	params.GraphIndex = GraphIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (Param != nullptr)
		*Param = params.Param;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AutoTestSystemComponent.RemoveTaskGraph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskGraph*            Graph                          (Parm, ZeroConstructor, IsPlainOldData)

void UAutoTestSystemComponent::RemoveTaskGraph(class UATTaskGraph* Graph)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestSystemComponent.RemoveTaskGraph");

	UAutoTestSystemComponent_RemoveTaskGraph_Params params;
	params.Graph = Graph;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AutoTestSystemComponent.ProcessTaskGraph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskGraph*            Graph                          (Parm, ZeroConstructor, IsPlainOldData)

void UAutoTestSystemComponent::ProcessTaskGraph(class UATTaskGraph* Graph)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestSystemComponent.ProcessTaskGraph");

	UAutoTestSystemComponent_ProcessTaskGraph_Params params;
	params.Graph = Graph;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AutoTestSystemComponent.AddTaskGraph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UATTaskGraph*            Graph                          (Parm, ZeroConstructor, IsPlainOldData)

void UAutoTestSystemComponent::AddTaskGraph(class UATTaskGraph* Graph)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AutoTestSystemComponent.AddTaskGraph");

	UAutoTestSystemComponent_AddTaskGraph_Params params;
	params.Graph = Graph;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.SetOBTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraCharacter*       PlayerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class UCharacterAvatarComponent* AvatarComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AAvatarCapture::SetOBTarget(class ASTExtraCharacter* PlayerPawn, class UCharacterAvatarComponent* AvatarComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.SetOBTarget");

	AAvatarCapture_SetOBTarget_Params params;
	params.PlayerPawn = PlayerPawn;
	params.AvatarComp = AvatarComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarCapture.SetEnable
// (Final, Native, Public)
// Parameters:
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void AAvatarCapture::SetEnable(bool IsEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.SetEnable");

	AAvatarCapture_SetEnable_Params params;
	params.IsEnable = IsEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.RenderCaptureScene
// (Final, Native, Public, BlueprintCallable)

void AAvatarCapture::RenderCaptureScene()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.RenderCaptureScene");

	AAvatarCapture_RenderCaptureScene_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.RefreshAvatar
// (Final, Native, Public)
// Parameters:
// EAvatarSlotType                slotType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isEquipped                     (Parm, ZeroConstructor, IsPlainOldData)

void AAvatarCapture::RefreshAvatar(EAvatarSlotType slotType, bool isEquipped)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.RefreshAvatar");

	AAvatarCapture_RefreshAvatar_Params params;
	params.slotType = slotType;
	params.isEquipped = isEquipped;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.MergeMesh
// (Final, Native, Public, HasOutParms)
// Parameters:
// TArray<class USkeletalMesh*>   SkMeshList                     (Parm, OutParm, ZeroConstructor)
// class USkeletalMesh*           RefMesh                        (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USkeletalMesh* AAvatarCapture::MergeMesh(class USkeletalMesh* RefMesh, TArray<class USkeletalMesh*>* SkMeshList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.MergeMesh");

	AAvatarCapture_MergeMesh_Params params;
	params.RefMesh = RefMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (SkMeshList != nullptr)
		*SkMeshList = params.SkMeshList;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarCapture.GetOBAvatarComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAvatarComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCharacterAvatarComponent* AAvatarCapture::GetOBAvatarComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.GetOBAvatarComponent");

	AAvatarCapture_GetOBAvatarComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarCapture.GetAnimSeqAsset
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FSoftObjectPath         AnimResRef                     (Parm)
// class UAnimSequenceBase*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UAnimSequenceBase* AAvatarCapture::GetAnimSeqAsset(const struct FSoftObjectPath& AnimResRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.GetAnimSeqAsset");

	AAvatarCapture_GetAnimSeqAsset_Params params;
	params.AnimResRef = AnimResRef;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarCapture.EquipWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            PlayerKey                      (Parm, ZeroConstructor, IsPlainOldData)

void AAvatarCapture::EquipWeapon(int PlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.EquipWeapon");

	AAvatarCapture_EquipWeapon_Params params;
	params.PlayerKey = PlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.EquipPlayerAvatar
// (Final, Native, Public)
// Parameters:
// class UCharacterAvatarComponent* AvatarComponent                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AAvatarCapture::EquipPlayerAvatar(class UCharacterAvatarComponent* AvatarComponent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.EquipPlayerAvatar");

	AAvatarCapture_EquipPlayerAvatar_Params params;
	params.AvatarComponent = AvatarComponent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.DisplayAvatar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraCharacter*       PlayerPawn                     (Parm, ZeroConstructor, IsPlainOldData)

void AAvatarCapture::DisplayAvatar(bool IsEnable, class ASTExtraCharacter* PlayerPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.DisplayAvatar");

	AAvatarCapture_DisplayAvatar_Params params;
	params.IsEnable = IsEnable;
	params.PlayerPawn = PlayerPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.CreateWeapon
// (Final, Native, Public)
// Parameters:
// bool                           IsSkeletalMesh                 (Parm, ZeroConstructor, IsPlainOldData)

void AAvatarCapture::CreateWeapon(bool IsSkeletalMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.CreateWeapon");

	AAvatarCapture_CreateWeapon_Params params;
	params.IsSkeletalMesh = IsSkeletalMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarCapture.ApplyAnimation
// (Final, Native, Public, BlueprintCallable)

void AAvatarCapture::ApplyAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarCapture.ApplyAnimation");

	AAvatarCapture_ApplyAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ShowAttachmentByIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIsVisible                     (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::ShowAttachmentByIndex(int Index, bool bIsVisible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ShowAttachmentByIndex");

	UAvatarComponent_ShowAttachmentByIndex_Params params;
	params.Index = Index;
	params.bIsVisible = bIsVisible;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ResetComponentMaster
// (Final, Native, Public, BlueprintCallable)

void UAvatarComponent::ResetComponentMaster()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ResetComponentMaster");

	UAvatarComponent_ResetComponentMaster_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ResetAllAvataSlot
// (Final, Native, Public, BlueprintCallable)

void UAvatarComponent::ResetAllAvataSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ResetAllAvataSlot");

	UAvatarComponent_ResetAllAvataSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ReloadAllEquippedAvatar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ForceAutonoumous               (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::ReloadAllEquippedAvatar(bool ForceAutonoumous)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ReloadAllEquippedAvatar");

	UAvatarComponent_ReloadAllEquippedAvatar_Params params;
	params.ForceAutonoumous = ForceAutonoumous;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.PutOnEquipmentByResID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::PutOnEquipmentByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.PutOnEquipmentByResID");

	UAvatarComponent_PutOnEquipmentByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.PutOnEquipmentByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           skMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             stMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::PutOnEquipmentByItemHandle(class UBattleItemHandleBase* ItemHandle, class USkeletalMesh* skMesh, class UStaticMesh* stMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.PutOnEquipmentByItemHandle");

	UAvatarComponent_PutOnEquipmentByItemHandle_Params params;
	params.ItemHandle = ItemHandle;
	params.skMesh = skMesh;
	params.stMesh = stMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.PutOffEquimentByResID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::PutOffEquimentByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.PutOffEquimentByResID");

	UAvatarComponent_PutOffEquimentByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.PutOffEquiment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::PutOffEquiment(int Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.PutOffEquiment");

	UAvatarComponent_PutOffEquiment_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.OnAsyncLoadMesh
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FSoftObjectPath         AssetRef                       (Parm)
// bool                           isReplaced                     (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::OnAsyncLoadMesh(const struct FSoftObjectPath& AssetRef, bool isReplaced)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.OnAsyncLoadMesh");

	UAvatarComponent_OnAsyncLoadMesh_Params params;
	params.AssetRef = AssetRef;
	params.isReplaced = isReplaced;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.LoadMeshsAsync
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   handleList                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           needDirectLoad                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::LoadMeshsAsync(class UBattleItemHandleBase* handleList, bool needDirectLoad)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.LoadMeshsAsync");

	UAvatarComponent_LoadMeshsAsync_Params params;
	params.handleList = handleList;
	params.needDirectLoad = needDirectLoad;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.IsTeammate
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::IsTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.IsTeammate");

	UAvatarComponent_IsTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.IsSlotHasEquipped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::IsSlotHasEquipped(int Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.IsSlotHasEquipped");

	UAvatarComponent_IsSlotHasEquipped_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.IsNeedReplaced
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackAvatarHandle*   doReplaceHandle                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::IsNeedReplaced(class UBackpackAvatarHandle* doReplaceHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.IsNeedReplaced");

	UAvatarComponent_IsNeedReplaced_Params params;
	params.doReplaceHandle = doReplaceHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.InitDefaultMesh
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::InitDefaultMesh(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.InitDefaultMesh");

	UAvatarComponent_InitDefaultMesh_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.InitDefaultAvatar
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::InitDefaultAvatar(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.InitDefaultAvatar");

	UAvatarComponent_InitDefaultAvatar_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.GetStaticMesh
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FMeshPackage            meshPack                       (ConstParm, Parm, OutParm, ReferenceParm)
// class UStaticMesh*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UStaticMesh* UAvatarComponent::GetStaticMesh(const struct FMeshPackage& meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetStaticMesh");

	UAvatarComponent_GetStaticMesh_Params params;
	params.meshPack = meshPack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetSlotDefinedID
// (Final, Native, Public)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID UAvatarComponent::GetSlotDefinedID(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetSlotDefinedID");

	UAvatarComponent_GetSlotDefinedID_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetSkeletalMesh
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FMeshPackage            meshPack                       (ConstParm, Parm, OutParm, ReferenceParm)
// class USkeletalMesh*           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USkeletalMesh* UAvatarComponent::GetSkeletalMesh(const struct FMeshPackage& meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetSkeletalMesh");

	UAvatarComponent_GetSkeletalMesh_Params params;
	params.meshPack = meshPack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetMaterial
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FMeshPackage            meshPack                       (ConstParm, Parm, OutParm, ReferenceParm)
// class UMaterialInstance*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInstance* UAvatarComponent::GetMaterial(const struct FMeshPackage& meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetMaterial");

	UAvatarComponent_GetMaterial_Params params;
	params.meshPack = meshPack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetEquimentMeshBySlot
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FMeshData               meshPack                       (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::GetEquimentMeshBySlot(int Slot, struct FMeshData* meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetEquimentMeshBySlot");

	UAvatarComponent_GetEquimentMeshBySlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshPack != nullptr)
		*meshPack = params.meshPack;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetAvatarSlotTypeFromInt
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            SlotTypeValue                  (Parm, ZeroConstructor, IsPlainOldData)
// EAvatarSlotType                ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EAvatarSlotType UAvatarComponent::GetAvatarSlotTypeFromInt(int SlotTypeValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetAvatarSlotTypeFromInt");

	UAvatarComponent_GetAvatarSlotTypeFromInt_Params params;
	params.SlotTypeValue = SlotTypeValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.GetApplyMeshType
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// EMeshType                      ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EMeshType UAvatarComponent::GetApplyMeshType(int Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.GetApplyMeshType");

	UAvatarComponent_GetApplyMeshType_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.ClearMeshBySlot
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           putDefault                     (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::ClearMeshBySlot(int Slot, bool putDefault)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ClearMeshBySlot");

	UAvatarComponent_ClearMeshBySlot_Params params;
	params.Slot = Slot;
	params.putDefault = putDefault;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ClearMeshByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::ClearMeshByItemHandle(class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ClearMeshByItemHandle");

	UAvatarComponent_ClearMeshByItemHandle_Params params;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ApplyStaticMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             pSM                            (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::ApplyStaticMeshByID(int Slot, class UStaticMesh* pSM, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ApplyStaticMeshByID");

	UAvatarComponent_ApplyStaticMeshByID_Params params;
	params.Slot = Slot;
	params.pSM = pSM;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.ApplySkeletalMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           Mesh                           (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UAvatarComponent::ApplySkeletalMeshByID(int Slot, class USkeletalMesh* Mesh, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ApplySkeletalMeshByID");

	UAvatarComponent_ApplySkeletalMeshByID_Params params;
	params.Slot = Slot;
	params.Mesh = Mesh;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarComponent.ApplyMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMeshComponent*          Component                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class USkeletalMesh*           SkeletalMesh                   (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             StaticMesh                     (Parm, ZeroConstructor, IsPlainOldData)

void UAvatarComponent::ApplyMesh(class UMeshComponent* Component, class USkeletalMesh* SkeletalMesh, class UStaticMesh* StaticMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ApplyMesh");

	UAvatarComponent_ApplyMesh_Params params;
	params.Component = Component;
	params.SkeletalMesh = SkeletalMesh;
	params.StaticMesh = StaticMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ApplyMaterial
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UAvatarComponent::ApplyMaterial(class UBattleItemHandleBase* ItemHandle, class UMeshComponent* meshComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ApplyMaterial");

	UAvatarComponent_ApplyMaterial_Params params;
	params.ItemHandle = ItemHandle;
	params.meshComp = meshComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarComponent.ApplyConfig
// (Final, Native, Public, BlueprintCallable)

void UAvatarComponent::ApplyConfig()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarComponent.ApplyConfig");

	UAvatarComponent_ApplyConfig_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarDisplayPoseComponent.SpawnAvatar
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UAvatarDisplayPoseComponent::SpawnAvatar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarDisplayPoseComponent.SpawnAvatar");

	UAvatarDisplayPoseComponent_SpawnAvatar_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.AvatarUtils.GetAvatarDataTableRowByID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           definedID                      (Parm)
// struct FAvatarItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FAvatarItemData UAvatarUtils::GetAvatarDataTableRowByID(const struct FItemDefineID& definedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarUtils.GetAvatarDataTableRowByID");

	UAvatarUtils_GetAvatarDataTableRowByID_Params params;
	params.definedID = definedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarUtils.ConstructAvatarItemDataFromTable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           definedID                      (Parm)
// struct FAvatarItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FAvatarItemData UAvatarUtils::ConstructAvatarItemDataFromTable(const struct FItemDefineID& definedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarUtils.ConstructAvatarItemDataFromTable");

	UAvatarUtils_ConstructAvatarItemDataFromTable_Params params;
	params.definedID = definedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarBPUtils.GetAvatarDataTableRowByID
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FItemDefineID           definedID                      (Parm)
// struct FAvatarItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FAvatarItemData UAvatarBPUtils::GetAvatarDataTableRowByID(const struct FItemDefineID& definedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarBPUtils.GetAvatarDataTableRowByID");

	UAvatarBPUtils_GetAvatarDataTableRowByID_Params params;
	params.definedID = definedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.AvatarBPUtils.ConstructAvatarItemDataFromTable
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FItemDefineID           definedID                      (Parm)
// struct FAvatarItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FAvatarItemData UAvatarBPUtils::ConstructAvatarItemDataFromTable(const struct FItemDefineID& definedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.AvatarBPUtils.ConstructAvatarItemDataFromTable");

	UAvatarBPUtils_ConstructAvatarItemDataFromTable_Params params;
	params.definedID = definedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.OnCharacterAttrChangedWithDetailEvent
// (Final, Native, Public)
// Parameters:
// class AActor*                  Owner                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 AttrName                       (Parm, ZeroConstructor)
// float                          deltaVal                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          resultVal                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackAvatarHandle::OnCharacterAttrChangedWithDetailEvent(class AActor* Owner, const struct FString& AttrName, float deltaVal, float resultVal)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.OnCharacterAttrChangedWithDetailEvent");

	UBackpackAvatarHandle_OnCharacterAttrChangedWithDetailEvent_Params params;
	params.Owner = Owner;
	params.AttrName = AttrName;
	params.deltaVal = deltaVal;
	params.resultVal = resultVal;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.HandleUse
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// struct FBattleItemUseTarget    Target                         (Parm)
// EBattleItemUseReason           Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::HandleUse(const struct FBattleItemUseTarget& Target, EBattleItemUseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.HandleUse");

	UBackpackAvatarHandle_HandleUse_Params params;
	params.Target = Target;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.HandlePickup
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// TScriptInterface<class UItemContainerInterface> ItemContainer                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// struct FBattleItemPickupInfo   PickupInfo                     (Parm)
// EBattleItemPickupReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::HandlePickup(const TScriptInterface<class UItemContainerInterface>& ItemContainer, const struct FBattleItemPickupInfo& PickupInfo, EBattleItemPickupReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.HandlePickup");

	UBackpackAvatarHandle_HandlePickup_Params params;
	params.ItemContainer = ItemContainer;
	params.PickupInfo = PickupInfo;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.HandleEnable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::HandleEnable(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.HandleEnable");

	UBackpackAvatarHandle_HandleEnable_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.HandleDrop
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int                            InCount                        (Parm, ZeroConstructor, IsPlainOldData)
// EBattleItemDropReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::HandleDrop(int InCount, EBattleItemDropReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.HandleDrop");

	UBackpackAvatarHandle_HandleDrop_Params params;
	params.InCount = InCount;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.HandleDisuse
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EBattleItemDisuseReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::HandleDisuse(EBattleItemDisuseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.HandleDisuse");

	UBackpackAvatarHandle_HandleDisuse_Params params;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.GetBackpackComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBackpackComponent* UBackpackAvatarHandle::GetBackpackComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.GetBackpackComponent");

	UBackpackAvatarHandle_GetBackpackComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackAvatarHandle.CheckCanPickUp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAvatarComponent* AvatarComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            nowCapcity                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackAvatarHandle::CheckCanPickUp(class UCharacterAvatarComponent* AvatarComp, int nowCapcity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackAvatarHandle.CheckCanPickUp");

	UBackpackAvatarHandle_CheckCanPickUp_Params params;
	params.AvatarComp = AvatarComp;
	params.nowCapcity = nowCapcity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.HandleUse
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// struct FBattleItemUseTarget    Target                         (Parm)
// EBattleItemUseReason           Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackEmoteHandle::HandleUse(const struct FBattleItemUseTarget& Target, EBattleItemUseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.HandleUse");

	UBackpackEmoteHandle_HandleUse_Params params;
	params.Target = Target;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.HandlePickup
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// TScriptInterface<class UItemContainerInterface> ItemContainer                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// struct FBattleItemPickupInfo   PickupInfo                     (Parm)
// EBattleItemPickupReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackEmoteHandle::HandlePickup(const TScriptInterface<class UItemContainerInterface>& ItemContainer, const struct FBattleItemPickupInfo& PickupInfo, EBattleItemPickupReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.HandlePickup");

	UBackpackEmoteHandle_HandlePickup_Params params;
	params.ItemContainer = ItemContainer;
	params.PickupInfo = PickupInfo;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.HandleDrop
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int                            InCount                        (Parm, ZeroConstructor, IsPlainOldData)
// EBattleItemDropReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackEmoteHandle::HandleDrop(int InCount, EBattleItemDropReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.HandleDrop");

	UBackpackEmoteHandle_HandleDrop_Params params;
	params.InCount = InCount;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.HandleDisuse
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EBattleItemDisuseReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackEmoteHandle::HandleDisuse(EBattleItemDisuseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.HandleDisuse");

	UBackpackEmoteHandle_HandleDisuse_Params params;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.GetBackpackComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBackpackComponent* UBackpackEmoteHandle::GetBackpackComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.GetBackpackComponent");

	UBackpackEmoteHandle_GetBackpackComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackEmoteHandle.CheckCanPickUp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAvatarComponent* AvatarComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            nowCapcity                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackEmoteHandle::CheckCanPickUp(class UCharacterAvatarComponent* AvatarComp, int nowCapcity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackEmoteHandle.CheckCanPickUp");

	UBackpackEmoteHandle_CheckCanPickUp_Params params;
	params.AvatarComp = AvatarComp;
	params.nowCapcity = nowCapcity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ReuseListForUI.ShiftRound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           REVERT                         (Parm, ZeroConstructor, IsPlainOldData)

void UReuseListForUI::ShiftRound(bool REVERT)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ReuseListForUI.ShiftRound");

	UReuseListForUI_ShiftRound_Params params;
	params.REVERT = REVERT;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ReuseListForUI.Reset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Length                         (Parm, ZeroConstructor, IsPlainOldData)

void UReuseListForUI::Reset(int Length)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ReuseListForUI.Reset");

	UReuseListForUI_Reset_Params params;
	params.Length = Length;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ReuseListForUI.Get
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UReuseListForUI::Get(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ReuseListForUI.Get");

	UReuseListForUI_Get_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.SortDefineIDByWeight
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FItemDefineSortingInfo> DefineIDList                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FItemDefineSortingInfo> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FItemDefineSortingInfo> UBackpackUtils::SortDefineIDByWeight(TArray<struct FItemDefineSortingInfo> DefineIDList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.SortDefineIDByWeight");

	UBackpackUtils_SortDefineIDByWeight_Params params;
	params.DefineIDList = DefineIDList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.SortBattleSearchItemList
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FBattleSearchItemSortingInfo> ItemList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FBattleSearchItemSortingInfo> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleSearchItemSortingInfo> UBackpackUtils::SortBattleSearchItemList(TArray<struct FBattleSearchItemSortingInfo> ItemList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.SortBattleSearchItemList");

	UBackpackUtils_SortBattleSearchItemList_Params params;
	params.ItemList = ItemList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.SortBattleSearchBoxList
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FBattleSearchBoxSortingInfo> BoxList                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FBattleSearchBoxSortingInfo> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleSearchBoxSortingInfo> UBackpackUtils::SortBattleSearchBoxList(TArray<struct FBattleSearchBoxSortingInfo> BoxList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.SortBattleSearchBoxList");

	UBackpackUtils_SortBattleSearchBoxList_Params params;
	params.BoxList = BoxList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.SortBattleItemList
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FBattleItemSortingInfo> ItemList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FBattleItemSortingInfo> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemSortingInfo> UBackpackUtils::SortBattleItemList(TArray<struct FBattleItemSortingInfo> ItemList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.SortBattleItemList");

	UBackpackUtils_SortBattleItemList_Params params;
	params.ItemList = ItemList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ReturnIteratively
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (Parm)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bCallHandlePickup              (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::ReturnIteratively(class UBackpackComponent* BackpackComp, const struct FItemDefineID& DefineID, int Count, bool bCallHandlePickup)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ReturnIteratively");

	UBackpackUtils_ReturnIteratively_Params params;
	params.BackpackComp = BackpackComp;
	params.DefineID = DefineID;
	params.Count = Count;
	params.bCallHandlePickup = bCallHandlePickup;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.PickupFromGround
// (Final, Native, Static, Public)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class APickUpWrapperActor*     Source                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FBattleItemUseTarget    AutoEquipTarget                (Parm)
// bool                           bForceAutoEquip                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackUtils::PickupFromGround(class UBackpackComponent* BackpackComp, class APickUpWrapperActor* Source, const struct FBattleItemUseTarget& AutoEquipTarget, bool bForceAutoEquip, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.PickupFromGround");

	UBackpackUtils_PickupFromGround_Params params;
	params.BackpackComp = BackpackComp;
	params.Source = Source;
	params.AutoEquipTarget = AutoEquipTarget;
	params.bForceAutoEquip = bForceAutoEquip;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.ItemNet2Data
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FNetArrayUnit           netItem                        (ConstParm, Parm, OutParm, ReferenceParm)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackUtils::ItemNet2Data(const struct FNetArrayUnit& netItem)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ItemNet2Data");

	UBackpackUtils_ItemNet2Data_Params params;
	params.netItem = netItem;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsUnvisibleItem
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsUnvisibleItem(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsUnvisibleItem");

	UBackpackUtils_IsUnvisibleItem_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsTaskItemType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsTaskItemType(int ItemType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsTaskItemType");

	UBackpackUtils_IsTaskItemType_Params params;
	params.ItemType = ItemType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsScoreItemType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsScoreItemType(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsScoreItemType");

	UBackpackUtils_IsScoreItemType_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsSameItem
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID1                      (ConstParm, Parm, OutParm, ReferenceParm)
// struct FItemDefineID           DefineID2                      (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsSameItem(const struct FItemDefineID& DefineID1, const struct FItemDefineID& DefineID2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsSameItem");

	UBackpackUtils_IsSameItem_Params params;
	params.DefineID1 = DefineID1;
	params.DefineID2 = DefineID2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsSameInstance
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID1                      (ConstParm, Parm, OutParm, ReferenceParm)
// struct FItemDefineID           DefineID2                      (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsSameInstance(const struct FItemDefineID& DefineID1, const struct FItemDefineID& DefineID2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsSameInstance");

	UBackpackUtils_IsSameInstance_Params params;
	params.DefineID1 = DefineID1;
	params.DefineID2 = DefineID2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsNotDropItem
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsNotDropItem(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsNotDropItem");

	UBackpackUtils_IsNotDropItem_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsGunItemType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsGunItemType(int ItemType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsGunItemType");

	UBackpackUtils_IsGunItemType_Params params;
	params.ItemType = ItemType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.IsCharacterVirtualItem
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (Parm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::IsCharacterVirtualItem(class UBackpackComponent* BackpackComp, const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.IsCharacterVirtualItem");

	UBackpackUtils_IsCharacterVirtualItem_Params params;
	params.BackpackComp = BackpackComp;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.InitialItemTable
// (Final, Native, Static, Public, BlueprintCallable)

void UBackpackUtils::InitialItemTable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.InitialItemTable");

	UBackpackUtils_InitialItemTable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.HasItemBySubType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            subType                        (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::HasItemBySubType(int subType, class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.HasItemBySubType");

	UBackpackUtils_HasItemBySubType_Params params;
	params.subType = subType;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetWeaponsInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetWeaponsInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetWeaponsInBackpack");

	UBackpackUtils_GetWeaponsInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetWeaponAttachmentsInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetWeaponAttachmentsInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetWeaponAttachmentsInBackpack");

	UBackpackUtils_GetWeaponAttachmentsInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetWeaponAttachmentHandles
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<class UBattleItemHandleBase*> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class UBattleItemHandleBase*> UBackpackUtils::GetWeaponAttachmentHandles(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetWeaponAttachmentHandles");

	UBackpackUtils_GetWeaponAttachmentHandles_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.getSocketByAttachResID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// EWeaponAttachmentSocketType    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EWeaponAttachmentSocketType UBackpackUtils::getSocketByAttachResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.getSocketByAttachResID");

	UBackpackUtils_getSocketByAttachResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetRawBattleTextByType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// EBattleTextType                Type                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackUtils::GetRawBattleTextByType(EBattleTextType Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetRawBattleTextByType");

	UBackpackUtils_GetRawBattleTextByType_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetRawBattleTextByRawTextID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackUtils::GetRawBattleTextByRawTextID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetRawBattleTextByRawTextID");

	UBackpackUtils_GetRawBattleTextByRawTextID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetPickupItemResultIndentify
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FSearchedPickUpItemResult SearchItemResult               (ConstParm, Parm, OutParm, ReferenceParm)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::GetPickupItemResultIndentify(const struct FSearchedPickUpItemResult& SearchItemResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetPickupItemResultIndentify");

	UBackpackUtils_GetPickupItemResultIndentify_Params params;
	params.SearchItemResult = SearchItemResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetItemUseful
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UWeaponManagerComponent* weaponComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (ConstParm, Parm, OutParm, ReferenceParm)
// struct FSearchedPickUpItemResult SearchItemResult               (ConstParm, Parm, OutParm, ReferenceParm)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::GetItemUseful(class UBackpackComponent* BackpackComp, class UWeaponManagerComponent* weaponComp, const struct FItemDefineID& DefineID, const struct FSearchedPickUpItemResult& SearchItemResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetItemUseful");

	UBackpackUtils_GetItemUseful_Params params;
	params.BackpackComp = BackpackComp;
	params.weaponComp = weaponComp;
	params.DefineID = DefineID;
	params.SearchItemResult = SearchItemResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetItemRecord
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemRecordData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemRecordData UBackpackUtils::GetItemRecord(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetItemRecord");

	UBackpackUtils_GetItemRecord_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetItemCountByDefineIDUnEquip
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (Parm)
// bool                           bOnlyInstance                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::GetItemCountByDefineIDUnEquip(class UBackpackComponent* BackpackComp, const struct FItemDefineID& DefineID, bool bOnlyInstance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetItemCountByDefineIDUnEquip");

	UBackpackUtils_GetItemCountByDefineIDUnEquip_Params params;
	params.BackpackComp = BackpackComp;
	params.DefineID = DefineID;
	params.bOnlyInstance = bOnlyInstance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetItemCountByDefineID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (Parm)
// bool                           bOnlyInstance                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::GetItemCountByDefineID(class UBackpackComponent* BackpackComp, const struct FItemDefineID& DefineID, bool bOnlyInstance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetItemCountByDefineID");

	UBackpackUtils_GetItemCountByDefineID_Params params;
	params.BackpackComp = BackpackComp;
	params.DefineID = DefineID;
	params.bOnlyInstance = bOnlyInstance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetEmoteItemInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetEmoteItemInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetEmoteItemInBackpack");

	UBackpackUtils_GetEmoteItemInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetDesignatedTypeItemInBackpack
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<int>                    DesignatedType                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetDesignatedTypeItemInBackpack(class UBackpackComponent* BackpackComp, TArray<int> DesignatedType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetDesignatedTypeItemInBackpack");

	UBackpackUtils_GetDesignatedTypeItemInBackpack_Params params;
	params.BackpackComp = BackpackComp;
	params.DesignatedType = DesignatedType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetConsumablesInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetConsumablesInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetConsumablesInBackpack");

	UBackpackUtils_GetConsumablesInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetClothingAndArmorInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetClothingAndArmorInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetClothingAndArmorInBackpack");

	UBackpackUtils_GetClothingAndArmorInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetCharacterVirtualItemInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackUtils::GetCharacterVirtualItemInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetCharacterVirtualItemInBackpack");

	UBackpackUtils_GetCharacterVirtualItemInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetCharacterVirtualItemHandleInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UBattleItemHandleBase*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBattleItemHandleBase* UBackpackUtils::GetCharacterVirtualItemHandleInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetCharacterVirtualItemHandleInBackpack");

	UBackpackUtils_GetCharacterVirtualItemHandleInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBPUtils
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackBlueprintUtils* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBackpackBlueprintUtils* UBackpackUtils::GetBPUtils()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBPUtils");

	UBackpackUtils_GetBPUtils_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBPTableNameByItemID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackUtils::GetBPTableNameByItemID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBPTableNameByItemID");

	UBackpackUtils_GetBPTableNameByItemID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBPIDByResID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackUtils::GetBPIDByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBPIDByResID");

	UBackpackUtils_GetBPIDByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBattleWeaponItemDisplayDataByDefineID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleWeaponItemDisplayData ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleWeaponItemDisplayData UBackpackUtils::GetBattleWeaponItemDisplayDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBattleWeaponItemDisplayDataByDefineID");

	UBackpackUtils_GetBattleWeaponItemDisplayDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBattleItemFeatureDataByDefineID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleItemFeatureData  ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemFeatureData UBackpackUtils::GetBattleItemFeatureDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBattleItemFeatureDataByDefineID");

	UBackpackUtils_GetBattleItemFeatureDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetBackpackItemType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FItemDefineID           ItemDefineID                   (ConstParm, Parm)
// TEnumAsByte<EBackpackItemType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EBackpackItemType> UBackpackUtils::GetBackpackItemType(const struct FItemDefineID& ItemDefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetBackpackItemType");

	UBackpackUtils_GetBackpackItemType_Params params;
	params.ItemDefineID = ItemDefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GetAttackTipDataByDamageEventType
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            subType                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 OutAttackName                  (Parm, OutParm, ZeroConstructor)
// struct FString                 OutAttackActionName            (Parm, OutParm, ZeroConstructor)

void UBackpackUtils::GetAttackTipDataByDamageEventType(int DamageType, int subType, struct FString* OutAttackName, struct FString* OutAttackActionName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetAttackTipDataByDamageEventType");

	UBackpackUtils_GetAttackTipDataByDamageEventType_Params params;
	params.DamageType = DamageType;
	params.subType = subType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutAttackName != nullptr)
		*OutAttackName = params.OutAttackName;
	if (OutAttackActionName != nullptr)
		*OutAttackActionName = params.OutAttackActionName;
}


// Function ShadowTrackerExtra.BackpackUtils.GetAllItemsInBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           bIncludeVirtualItems           (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> UBackpackUtils::GetAllItemsInBackpack(class UBackpackComponent* BackpackComp, bool bIncludeVirtualItems)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GetAllItemsInBackpack");

	UBackpackUtils_GetAllItemsInBackpack_Params params;
	params.BackpackComp = BackpackComp;
	params.bIncludeVirtualItems = bIncludeVirtualItems;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GenerateRandomInstanceID
// (Final, Native, Static, Public)
// Parameters:
// uint64_t                       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

uint64_t UBackpackUtils::GenerateRandomInstanceID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GenerateRandomInstanceID");

	UBackpackUtils_GenerateRandomInstanceID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GenerateItemDefineIDWithRandomInstanceID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            Type                           (Parm, ZeroConstructor, IsPlainOldData)
// int                            TypeSpecificID                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID UBackpackUtils::GenerateItemDefineIDWithRandomInstanceID(int Type, int TypeSpecificID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GenerateItemDefineIDWithRandomInstanceID");

	UBackpackUtils_GenerateItemDefineIDWithRandomInstanceID_Params params;
	params.Type = Type;
	params.TypeSpecificID = TypeSpecificID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.GenerateItemDefineIDByItemTableIDWithRandomInstanceID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemTableID                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID UBackpackUtils::GenerateItemDefineIDByItemTableIDWithRandomInstanceID(int ItemTableID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.GenerateItemDefineIDByItemTableIDWithRandomInstanceID");

	UBackpackUtils_GenerateItemDefineIDByItemTableIDWithRandomInstanceID_Params params;
	params.ItemTableID = ItemTableID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ForceDropItemCannotCarryOnPlane
// (Final, Native, Static, Public)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UBackpackUtils::ForceDropItemCannotCarryOnPlane(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ForceDropItemCannotCarryOnPlane");

	UBackpackUtils_ForceDropItemCannotCarryOnPlane_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.ForceDropAll
// (Final, Native, Static, Public)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UBackpackUtils::ForceDropAll(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ForceDropAll");

	UBackpackUtils_ForceDropAll_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.ExtractPickupWrapperItems
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<struct FPickUpWrapperItem> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FPickUpWrapperItem> UBackpackUtils::ExtractPickupWrapperItems(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ExtractPickupWrapperItems");

	UBackpackUtils_ExtractPickupWrapperItems_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.EnableItemBySubType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            subType                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UBackpackUtils::EnableItemBySubType(int subType, bool bEnable, class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.EnableItemBySubType");

	UBackpackUtils_EnableItemBySubType_Params params;
	params.subType = subType;
	params.bEnable = bEnable;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.CreateBattleItemHandleAsync
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UObject*                 Outer                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FScriptDelegate         Delegate                       (Parm, ZeroConstructor)

void UBackpackUtils::CreateBattleItemHandleAsync(const struct FItemDefineID& DefineID, class UObject* Outer, const struct FScriptDelegate& Delegate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.CreateBattleItemHandleAsync");

	UBackpackUtils_CreateBattleItemHandleAsync_Params params;
	params.DefineID = DefineID;
	params.Outer = Outer;
	params.Delegate = Delegate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.CreateBattleItemHandle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UObject*                 Outer                          (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBattleItemHandleBase* UBackpackUtils::CreateBattleItemHandle(const struct FItemDefineID& DefineID, class UObject* Outer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.CreateBattleItemHandle");

	UBackpackUtils_CreateBattleItemHandle_Params params;
	params.DefineID = DefineID;
	params.Outer = Outer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ConsumeItemByLobby
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::ConsumeItemByLobby(int ItemID, int Count, class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ConsumeItemByLobby");

	UBackpackUtils_ConsumeItemByLobby_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ConstructBattleItemDataByItemTableID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ItemTableID                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackUtils::ConstructBattleItemDataByItemTableID(int ItemTableID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ConstructBattleItemDataByItemTableID");

	UBackpackUtils_ConstructBattleItemDataByItemTableID_Params params;
	params.ItemTableID = ItemTableID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ConstructBattleItemDataByDefineID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackUtils::ConstructBattleItemDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ConstructBattleItemDataByDefineID");

	UBackpackUtils_ConstructBattleItemDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.ClearItemUsefulCacheByDefineID
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (ConstParm, Parm, OutParm, ReferenceParm)

void UBackpackUtils::ClearItemUsefulCacheByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ClearItemUsefulCacheByDefineID");

	UBackpackUtils_ClearItemUsefulCacheByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.ClearItemUsefulCache
// (Final, Native, Static, Public, BlueprintCallable)

void UBackpackUtils::ClearItemUsefulCache()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.ClearItemUsefulCache");

	UBackpackUtils_ClearItemUsefulCache_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackUtils.CheckItemUseful
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UWeaponManagerComponent* weaponComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FItemDefineID           DefineID                       (ConstParm, Parm, OutParm, ReferenceParm)
// struct FSearchedPickUpItemResult SearchItemResult               (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::CheckItemUseful(class UBackpackComponent* BackpackComp, class UWeaponManagerComponent* weaponComp, const struct FItemDefineID& DefineID, const struct FSearchedPickUpItemResult& SearchItemResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.CheckItemUseful");

	UBackpackUtils_CheckItemUseful_Params params;
	params.BackpackComp = BackpackComp;
	params.weaponComp = weaponComp;
	params.DefineID = DefineID;
	params.SearchItemResult = SearchItemResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.CheckCapacityForSwapOrDrop
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OldCapacity                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewCapacity                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackUtils::CheckCapacityForSwapOrDrop(class UBackpackComponent* BackpackComp, int OldCapacity, int NewCapacity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.CheckCapacityForSwapOrDrop");

	UBackpackUtils_CheckCapacityForSwapOrDrop_Params params;
	params.BackpackComp = BackpackComp;
	params.OldCapacity = OldCapacity;
	params.NewCapacity = NewCapacity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackUtils.AddCharacterVirtualItemHandleToBackpack
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackUtils::AddCharacterVirtualItemHandleToBackpack(class UBackpackComponent* BackpackComp, class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackUtils.AddCharacterVirtualItemHandleToBackpack");

	UBackpackUtils_AddCharacterVirtualItemHandleToBackpack_Params params;
	params.BackpackComp = BackpackComp;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.OnGameModeTypeChanged
// (Native, Event, Protected, BlueprintEvent)

void UBackpackBlueprintUtils::OnGameModeTypeChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.OnGameModeTypeChanged");

	UBackpackBlueprintUtils_OnGameModeTypeChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.IsVirtualItemData
// (Native, Event, Protected, HasOutParms, BlueprintEvent, Const)
// Parameters:
// struct FBattleItemData         ItemData                       (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackBlueprintUtils::IsVirtualItemData(const struct FBattleItemData& ItemData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.IsVirtualItemData");

	UBackpackBlueprintUtils_IsVirtualItemData_Params params;
	params.ItemData = ItemData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.InitialItemTable
// (Native, Event, Protected, BlueprintEvent)

void UBackpackBlueprintUtils::InitialItemTable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.InitialItemTable");

	UBackpackBlueprintUtils_InitialItemTable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetRawBattleTextByType
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// EBattleTextType                Type                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackBlueprintUtils::GetRawBattleTextByType(EBattleTextType Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetRawBattleTextByType");

	UBackpackBlueprintUtils_GetRawBattleTextByType_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetRawBattleTextByRawTextID
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackBlueprintUtils::GetRawBattleTextByRawTextID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetRawBattleTextByRawTextID");

	UBackpackBlueprintUtils_GetRawBattleTextByRawTextID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetItemSubTypeID
// (Event, Protected, BlueprintEvent)
// Parameters:
// int                            SpecificID                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackBlueprintUtils::GetItemSubTypeID(int SpecificID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetItemSubTypeID");

	UBackpackBlueprintUtils_GetItemSubTypeID_Params params;
	params.SpecificID = SpecificID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetCharacterVirtualItemInBackpack
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackBlueprintUtils::GetCharacterVirtualItemInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetCharacterVirtualItemInBackpack");

	UBackpackBlueprintUtils_GetCharacterVirtualItemInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetCharacterVirtualItemHandleInBackpack
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UBattleItemHandleBase*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBattleItemHandleBase* UBackpackBlueprintUtils::GetCharacterVirtualItemHandleInBackpack(class UBackpackComponent* BackpackComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetCharacterVirtualItemHandleInBackpack");

	UBackpackBlueprintUtils_GetCharacterVirtualItemHandleInBackpack_Params params;
	params.BackpackComp = BackpackComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBPTableNameByItemID
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackBlueprintUtils::GetBPTableNameByItemID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBPTableNameByItemID");

	UBackpackBlueprintUtils_GetBPTableNameByItemID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBPIDByResID
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBackpackBlueprintUtils::GetBPIDByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBPIDByResID");

	UBackpackBlueprintUtils_GetBPIDByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleWeaponItemDisplayDataByDefineID
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleWeaponItemDisplayData ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleWeaponItemDisplayData UBackpackBlueprintUtils::GetBattleWeaponItemDisplayDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleWeaponItemDisplayDataByDefineID");

	UBackpackBlueprintUtils_GetBattleWeaponItemDisplayDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleItemHandlePath
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBackpackBlueprintUtils::GetBattleItemHandlePath(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleItemHandlePath");

	UBackpackBlueprintUtils_GetBattleItemHandlePath_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleItemFeatureDataByDefineID
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleItemFeatureData  ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemFeatureData UBackpackBlueprintUtils::GetBattleItemFeatureDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GetBattleItemFeatureDataByDefineID");

	UBackpackBlueprintUtils_GetBattleItemFeatureDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.GenerateItemDefineIDByItemTableID
// (Native, Event, Protected, HasOutParms, BlueprintEvent, Const)
// Parameters:
// int                            ItemTableID                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            Type                           (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// int                            TypeSpecificID                 (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void UBackpackBlueprintUtils::GenerateItemDefineIDByItemTableID(int ItemTableID, int* Type, int* TypeSpecificID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.GenerateItemDefineIDByItemTableID");

	UBackpackBlueprintUtils_GenerateItemDefineIDByItemTableID_Params params;
	params.ItemTableID = ItemTableID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (Type != nullptr)
		*Type = params.Type;
	if (TypeSpecificID != nullptr)
		*TypeSpecificID = params.TypeSpecificID;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.CreateBattleItemHandle
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UObject*                 Outer                          (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBattleItemHandleBase* UBackpackBlueprintUtils::CreateBattleItemHandle(const struct FItemDefineID& DefineID, class UObject* Outer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.CreateBattleItemHandle");

	UBackpackBlueprintUtils_CreateBattleItemHandle_Params params;
	params.DefineID = DefineID;
	params.Outer = Outer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.ConstructBattleItemDataByItemTableID
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// int                            ItemTableID                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackBlueprintUtils::ConstructBattleItemDataByItemTableID(int ItemTableID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.ConstructBattleItemDataByItemTableID");

	UBackpackBlueprintUtils_ConstructBattleItemDataByItemTableID_Params params;
	params.ItemTableID = ItemTableID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.ConstructBattleItemDataByDefineID
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleItemData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FBattleItemData UBackpackBlueprintUtils::ConstructBattleItemDataByDefineID(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.ConstructBattleItemDataByDefineID");

	UBackpackBlueprintUtils_ConstructBattleItemDataByDefineID_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BackpackBlueprintUtils.AddCharacterVirtualItemToBackpack
// (Native, Event, Protected, BlueprintEvent, Const)
// Parameters:
// class UBackpackComponent*      BackpackComp                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackBlueprintUtils::AddCharacterVirtualItemToBackpack(class UBackpackComponent* BackpackComp, class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackBlueprintUtils.AddCharacterVirtualItemToBackpack");

	UBackpackBlueprintUtils_AddCharacterVirtualItemToBackpack_Params params;
	params.BackpackComp = BackpackComp;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackWeaponAttachHandle.ReturnWeaponAdditionalBulletsToBackpack
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class ASTExtraShootWeapon*     Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            BulletNum                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackWeaponAttachHandle::ReturnWeaponAdditionalBulletsToBackpack(class ASTExtraShootWeapon* Weapon, int BulletNum)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackWeaponAttachHandle.ReturnWeaponAdditionalBulletsToBackpack");

	UBackpackWeaponAttachHandle_ReturnWeaponAdditionalBulletsToBackpack_Params params;
	params.Weapon = Weapon;
	params.BulletNum = BulletNum;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackWeaponAttachHandle.ResetNeedReturnBulletsWhenDisuseExtendMaxBulletDJ
// (Final, Native, Public, BlueprintCallable)

void UBackpackWeaponAttachHandle::ResetNeedReturnBulletsWhenDisuseExtendMaxBulletDJ()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackWeaponAttachHandle.ResetNeedReturnBulletsWhenDisuseExtendMaxBulletDJ");

	UBackpackWeaponAttachHandle_ResetNeedReturnBulletsWhenDisuseExtendMaxBulletDJ_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackWeaponAttachHandle.HandleDisuseReplaceByNew
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackWeaponAttachHandle* NewHandle                      (Parm, ZeroConstructor, IsPlainOldData)

void UBackpackWeaponAttachHandle::HandleDisuseReplaceByNew(class UBackpackWeaponAttachHandle* NewHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackWeaponAttachHandle.HandleDisuseReplaceByNew");

	UBackpackWeaponAttachHandle_HandleDisuseReplaceByNew_Params params;
	params.NewHandle = NewHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BackpackWeaponAttachHandle.EquipOrUnEuipAttachment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraShootWeapon*     InWeapon                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsEquip                        (Parm, ZeroConstructor, IsPlainOldData)
// EBattleItemDisuseReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBackpackWeaponAttachHandle::EquipOrUnEuipAttachment(class ASTExtraShootWeapon* InWeapon, bool IsEquip, EBattleItemDisuseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BackpackWeaponAttachHandle.EquipOrUnEuipAttachment");

	UBackpackWeaponAttachHandle_EquipOrUnEuipAttachment_Params params;
	params.InWeapon = InWeapon;
	params.IsEquip = IsEquip;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BasicAIController.OnStartTree
// (Event, Public, BlueprintEvent)

void ABasicAIController::OnStartTree()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BasicAIController.OnStartTree");

	ABasicAIController_OnStartTree_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseAIController.Respawn
// (Native, Public, BlueprintCallable)

void ABaseAIController::Respawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseAIController.Respawn");

	ABaseAIController_Respawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseCharacterEffectCom.HandleOwnerDeath
// (Final, Native, Private, HasOutParms, HasDefaults)
// Parameters:
// class ASTExtraBaseCharacter*   DeadCharacter                  (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  KillingHitDamageType           (Parm, ZeroConstructor, IsPlainOldData)

void UBaseCharacterEffectCom::HandleOwnerDeath(class ASTExtraBaseCharacter* DeadCharacter, class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* KillingHitDamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseCharacterEffectCom.HandleOwnerDeath");

	UBaseCharacterEffectCom_HandleOwnerDeath_Params params;
	params.DeadCharacter = DeadCharacter;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.KillingHitDamageType = KillingHitDamageType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.UpdateScopeCameraOffsets
// (Final, Native, Protected, HasOutParms)
// Parameters:
// float                          FOV                            (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          Offset                         (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::UpdateScopeCameraOffsets(float* FOV, float* Offset)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.UpdateScopeCameraOffsets");

	UBaseFPPComponent_UpdateScopeCameraOffsets_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (FOV != nullptr)
		*FOV = params.FOV;
	if (Offset != nullptr)
		*Offset = params.Offset;
}


// Function ShadowTrackerExtra.BaseFPPComponent.SwitchSightConfigMaterial
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::SwitchSightConfigMaterial()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.SwitchSightConfigMaterial");

	UBaseFPPComponent_SwitchSightConfigMaterial_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.SwitchScopeMeshAnim
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScopeMeshAnimType> Type                           (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::SwitchScopeMeshAnim(TEnumAsByte<EScopeMeshAnimType> Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.SwitchScopeMeshAnim");

	UBaseFPPComponent_SwitchScopeMeshAnim_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.SwitchCameraMode
// (Final, Native, Protected)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::SwitchCameraMode(TEnumAsByte<EPlayerCameraMode> Mode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.SwitchCameraMode");

	UBaseFPPComponent_SwitchCameraMode_Params params;
	params.Mode = Mode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.StopScopeIn
// (Event, Protected, BlueprintEvent)

void UBaseFPPComponent::StopScopeIn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.StopScopeIn");

	UBaseFPPComponent_StopScopeIn_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ShowReflectorSightTPPMaterial
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::ShowReflectorSightTPPMaterial()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ShowReflectorSightTPPMaterial");

	UBaseFPPComponent_ShowReflectorSightTPPMaterial_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.SetTagCulling
// (Event, Protected, BlueprintEvent)
// Parameters:
// bool                           IsUse                          (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::SetTagCulling(bool IsUse)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.SetTagCulling");

	UBaseFPPComponent_SetTagCulling_Params params;
	params.IsUse = IsUse;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.SetNearClipPlane
// (Final, Native, Protected)
// Parameters:
// bool                           EnableNearClip                 (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::SetNearClipPlane(bool EnableNearClip)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.SetNearClipPlane");

	UBaseFPPComponent_SetNearClipPlane_Params params;
	params.EnableNearClip = EnableNearClip;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopingChange
// (Final, Native, Protected)
// Parameters:
// bool                           InValue                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopingChange(bool InValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopingChange");

	UBaseFPPComponent_ScopingChange_Params params;
	params.InValue = InValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.Scoping
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::Scoping(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.Scoping");

	UBaseFPPComponent_Scoping_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeZoomUpdate
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          alpha                          (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeZoomUpdate(float alpha)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeZoomUpdate");

	UBaseFPPComponent_ScopeZoomUpdate_Params params;
	params.alpha = alpha;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeZoomTick
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeZoomTick(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeZoomTick");

	UBaseFPPComponent_ScopeZoomTick_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeTimelineUpdate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          alpha                          (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeTimelineUpdate(float alpha)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeTimelineUpdate");

	UBaseFPPComponent_ScopeTimelineUpdate_Params params;
	params.alpha = alpha;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutSpeedChange
// (Final, Native, Protected)
// Parameters:
// class ASTExtraPlayerController* Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// class UShootWeaponEntity*      entity                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UBaseFPPComponent::ScopeOutSpeedChange(class ASTExtraPlayerController* Controller, class UShootWeaponEntity* entity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutSpeedChange");

	UBaseFPPComponent_ScopeOutSpeedChange_Params params;
	params.Controller = Controller;
	params.entity = entity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutLogic
// (Final, Native, Protected)

void UBaseFPPComponent::ScopeOutLogic()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutLogic");

	UBaseFPPComponent_ScopeOutLogic_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutEnd
// (Event, Protected, BlueprintEvent)

void UBaseFPPComponent::ScopeOutEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeOutEnd");

	UBaseFPPComponent_ScopeOutEnd_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeOut
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeOut(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeOut");

	UBaseFPPComponent_ScopeOut_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeNotHandFold
// (Final, Native, Public, BlueprintCallable)

void UBaseFPPComponent::ScopeNotHandFold()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeNotHandFold");

	UBaseFPPComponent_ScopeNotHandFold_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeInterrupt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeInterrupt(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeInterrupt");

	UBaseFPPComponent_ScopeInterrupt_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeInSpeedChange
// (Final, Native, Protected)
// Parameters:
// class ASTExtraPlayerController* Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// class UShootWeaponEntity*      entity                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UBaseFPPComponent::ScopeInSpeedChange(class ASTExtraPlayerController* Controller, class UShootWeaponEntity* entity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeInSpeedChange");

	UBaseFPPComponent_ScopeInSpeedChange_Params params;
	params.Controller = Controller;
	params.entity = entity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeInLogic
// (Final, Native, Protected)

void UBaseFPPComponent::ScopeInLogic()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeInLogic");

	UBaseFPPComponent_ScopeInLogic_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeInEnd
// (Event, Protected, BlueprintEvent)

void UBaseFPPComponent::ScopeInEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeInEnd");

	UBaseFPPComponent_ScopeInEnd_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeInAfterTimeline
// (Final, Native, Public, BlueprintCallable)

void UBaseFPPComponent::ScopeInAfterTimeline()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeInAfterTimeline");

	UBaseFPPComponent_ScopeInAfterTimeline_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::ScopeIn(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeIn");

	UBaseFPPComponent_ScopeIn_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ScopeHandFold
// (Final, Native, Public, BlueprintCallable)

void UBaseFPPComponent::ScopeHandFold()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ScopeHandFold");

	UBaseFPPComponent_ScopeHandFold_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.PlayScopeInTimeline
// (Event, Protected, BlueprintEvent)

void UBaseFPPComponent::PlayScopeInTimeline()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.PlayScopeInTimeline");

	UBaseFPPComponent_PlayScopeInTimeline_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.IsUseZoomScope
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseFPPComponent::IsUseZoomScope()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.IsUseZoomScope");

	UBaseFPPComponent_IsUseZoomScope_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.IsCurWeaponAttachedAngledSight
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseFPPComponent::IsCurWeaponAttachedAngledSight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.IsCurWeaponAttachedAngledSight");

	UBaseFPPComponent_IsCurWeaponAttachedAngledSight_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.InitScopeZoom
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            WeaponID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ScopeID                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::InitScopeZoom(int WeaponID, int ScopeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.InitScopeZoom");

	UBaseFPPComponent_InitScopeZoom_Params params;
	params.WeaponID = WeaponID;
	params.ScopeID = ScopeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.GetSightType
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ESightType>        ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESightType> UBaseFPPComponent::GetSightType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.GetSightType");

	UBaseFPPComponent_GetSightType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.GetScopeZoomValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            WeaponID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ScopeID                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::GetScopeZoomValue(int WeaponID, int ScopeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.GetScopeZoomValue");

	UBaseFPPComponent_GetScopeZoomValue_Params params;
	params.WeaponID = WeaponID;
	params.ScopeID = ScopeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.GetScopeZoomKey
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            WeaponID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ScopeID                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UBaseFPPComponent::GetScopeZoomKey(int WeaponID, int ScopeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.GetScopeZoomKey");

	UBaseFPPComponent_GetScopeZoomKey_Params params;
	params.WeaponID = WeaponID;
	params.ScopeID = ScopeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.GetScopeFov
// (Event, Protected, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class ASTExtraShootWeapon*     shootWeapon                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIsAngled                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::GetScopeFov(class ASTExtraShootWeapon* shootWeapon, bool bIsAngled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.GetScopeFov");

	UBaseFPPComponent_GetScopeFov_Params params;
	params.shootWeapon = shootWeapon;
	params.bIsAngled = bIsAngled;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.DetachSightLens
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::DetachSightLens()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.DetachSightLens");

	UBaseFPPComponent_DetachSightLens_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.BoltAction
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          DeltaSeconds                   (Parm, ZeroConstructor, IsPlainOldData)

void UBaseFPPComponent::BoltAction(float DeltaSeconds)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.BoltAction");

	UBaseFPPComponent_BoltAction_Params params;
	params.DeltaSeconds = DeltaSeconds;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.AttachToSight
// (Event, Protected, BlueprintEvent)

void UBaseFPPComponent::AttachToSight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.AttachToSight");

	UBaseFPPComponent_AttachToSight_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseFPPComponent.AttachSightLens
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBaseFPPComponent::AttachSightLens()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.AttachSightLens");

	UBaseFPPComponent_AttachSightLens_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseFPPComponent.ActiveComponentTickable
// (Final, Native, Protected)

void UBaseFPPComponent::ActiveComponentTickable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseFPPComponent.ActiveComponentTickable");

	UBaseFPPComponent_ActiveComponentTickable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.RetrieveTaskAreaType
// (Final, Native, Private, HasDefaults)
// Parameters:
// struct FVector                 PlayerLocation                 (Parm, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBaseTaskComponent::RetrieveTaskAreaType(const struct FVector& PlayerLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.RetrieveTaskAreaType");

	UBaseTaskComponent_RetrieveTaskAreaType_Params params;
	params.PlayerLocation = PlayerLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.RetrieveLandLocType
// (Final, Native, Private)
// Parameters:
// struct FString                 TargetName                     (Parm, ZeroConstructor)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBaseTaskComponent::RetrieveLandLocType(const struct FString& TargetName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.RetrieveLandLocType");

	UBaseTaskComponent_RetrieveLandLocType_Params params;
	params.TargetName = TargetName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.ReportTaskAndSpecialCollection
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskType>         TaskType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::ReportTaskAndSpecialCollection(TEnumAsByte<ETaskType> TaskType, int TaskID, int process)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.ReportTaskAndSpecialCollection");

	UBaseTaskComponent_ReportTaskAndSpecialCollection_Params params;
	params.TaskType = TaskType;
	params.TaskID = TaskID;
	params.process = process;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.RegisterEvent
// (Final, Native, Protected)
// Parameters:
// class UClass*                  RegisterEventClass             (Parm, ZeroConstructor, IsPlainOldData)
// class UUAETriggerObject*       TriggerListener                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETaskEventType>    TaskEventType                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::RegisterEvent(class UClass* RegisterEventClass, class UUAETriggerObject* TriggerListener, TEnumAsByte<ETaskEventType> TaskEventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.RegisterEvent");

	UBaseTaskComponent_RegisterEvent_Params params;
	params.RegisterEventClass = RegisterEventClass;
	params.TriggerListener = TriggerListener;
	params.TaskEventType = TaskEventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.IsTriggerActive
// (Final, Native, Public)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::IsTriggerActive(int InTaskID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.IsTriggerActive");

	UBaseTaskComponent_IsTriggerActive_Params params;
	params.InTaskID = InTaskID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.IsSpecialPickItem
// (Final, Native, Public)
// Parameters:
// int                            InItemID                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::IsSpecialPickItem(int InItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.IsSpecialPickItem");

	UBaseTaskComponent_IsSpecialPickItem_Params params;
	params.InItemID = InItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.IsInSpecifiedArea
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 PlayerLocation                 (Parm, IsPlainOldData)
// struct FString                 outAreaAnchorsStr              (Parm, ZeroConstructor)
// struct FString                 InMapName                      (Parm, ZeroConstructor)
// struct FString                 InTargetName                   (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::IsInSpecifiedArea(const struct FVector& PlayerLocation, const struct FString& outAreaAnchorsStr, const struct FString& InMapName, const struct FString& InTargetName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.IsInSpecifiedArea");

	UBaseTaskComponent_IsInSpecifiedArea_Params params;
	params.PlayerLocation = PlayerLocation;
	params.outAreaAnchorsStr = outAreaAnchorsStr;
	params.InMapName = InMapName;
	params.InTargetName = InTargetName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerPickupItem
// (Final, Native, Private)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::HandlePlayerPickupItem(int ItemID, int Count, class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerPickupItem");

	UBaseTaskComponent_HandlePlayerPickupItem_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerKilling
// (Final, Native, Private)

void UBaseTaskComponent::HandlePlayerKilling()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerKilling");

	UBaseTaskComponent_HandlePlayerKilling_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerEnterArea
// (Final, Native, Private)
// Parameters:
// int                            AreaID                         (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::HandlePlayerEnterArea(int AreaID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerEnterArea");

	UBaseTaskComponent_HandlePlayerEnterArea_Params params;
	params.AreaID = AreaID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerDropItem
// (Final, Native, Private)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::HandlePlayerDropItem(int ItemID, int Count, class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerDropItem");

	UBaseTaskComponent_HandlePlayerDropItem_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerDoEmote
// (Final, Native, Private)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::HandlePlayerDoEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandlePlayerDoEmote");

	UBaseTaskComponent_HandlePlayerDoEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandleInitTaskData
// (Final, Native, Private)
// Parameters:
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ext_info                       (Parm, ZeroConstructor)

void UBaseTaskComponent::HandleInitTaskData(int TaskID, int process, const struct FString& ext_info)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandleInitTaskData");

	UBaseTaskComponent_HandleInitTaskData_Params params;
	params.TaskID = TaskID;
	params.process = process;
	params.ext_info = ext_info;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandleInitCollectionData
// (Final, Native, Private)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurrentCount                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            TotalCount                     (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::HandleInitCollectionData(int ItemID, int CurrentCount, int TotalCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandleInitCollectionData");

	UBaseTaskComponent_HandleInitCollectionData_Params params;
	params.ItemID = ItemID;
	params.CurrentCount = CurrentCount;
	params.TotalCount = TotalCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.HandleDeathBoxSpawned
// (Final, Native, Private, HasDefaults)
// Parameters:
// struct FTransform              SpawnTransform                 (Parm, IsPlainOldData)

void UBaseTaskComponent::HandleDeathBoxSpawned(const struct FTransform& SpawnTransform)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.HandleDeathBoxSpawned");

	UBaseTaskComponent_HandleDeathBoxSpawned_Params params;
	params.SpawnTransform = SpawnTransform;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTriggerObject
// (Final, Native, Public)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// class UUAETriggerObject*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UUAETriggerObject* UBaseTaskComponent::GetTriggerObject(int InTaskID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTriggerObject");

	UBaseTaskComponent_GetTriggerObject_Params params;
	params.InTaskID = InTaskID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTaskSubTypeFromDataTable
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBaseTaskComponent::GetTaskSubTypeFromDataTable(int InTaskID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTaskSubTypeFromDataTable");

	UBaseTaskComponent_GetTaskSubTypeFromDataTable_Params params;
	params.InTaskID = InTaskID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTaskParamsFromDataTable
// (Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 outMainConditionParam          (Parm, OutParm, ZeroConstructor)
// int                            outTargetProcess               (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::GetTaskParamsFromDataTable(int InTaskID, struct FString* outMainConditionParam, int* outTargetProcess)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTaskParamsFromDataTable");

	UBaseTaskComponent_GetTaskParamsFromDataTable_Params params;
	params.InTaskID = InTaskID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outMainConditionParam != nullptr)
		*outMainConditionParam = params.outMainConditionParam;
	if (outTargetProcess != nullptr)
		*outTargetProcess = params.outTargetProcess;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTaskParams
// (Final, Native, Protected, HasOutParms)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 outMainConditionParamStr       (Parm, OutParm, ZeroConstructor)
// int                            outTaskProcess                 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::GetTaskParams(int InTaskID, struct FString* outMainConditionParamStr, int* outTaskProcess)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTaskParams");

	UBaseTaskComponent_GetTaskParams_Params params;
	params.InTaskID = InTaskID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outMainConditionParamStr != nullptr)
		*outMainConditionParamStr = params.outMainConditionParamStr;
	if (outTaskProcess != nullptr)
		*outTaskProcess = params.outTaskProcess;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTaskClassPath
// (Final, Native, Protected)
// Parameters:
// TEnumAsByte<ETaskType>         TaskType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            TaskUID                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBaseTaskComponent::GetTaskClassPath(TEnumAsByte<ETaskType> TaskType, int TaskUID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTaskClassPath");

	UBaseTaskComponent_GetTaskClassPath_Params params;
	params.TaskType = TaskType;
	params.TaskUID = TaskUID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetTaskAreaIDFromDataTable
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                 InPlayerLocation               (Parm, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBaseTaskComponent::GetTaskAreaIDFromDataTable(const struct FVector& InPlayerLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetTaskAreaIDFromDataTable");

	UBaseTaskComponent_GetTaskAreaIDFromDataTable_Params params;
	params.InPlayerLocation = InPlayerLocation;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetOwningPlayerName
// (Final, Native, Public)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBaseTaskComponent::GetOwningPlayerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetOwningPlayerName");

	UBaseTaskComponent_GetOwningPlayerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetMapName
// (Final, Native, Public)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UBaseTaskComponent::GetMapName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetMapName");

	UBaseTaskComponent_GetMapName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.GetLandLocIDFromDataTable
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 InTargetName                   (Parm, ZeroConstructor)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UBaseTaskComponent::GetLandLocIDFromDataTable(const struct FString& InTargetName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.GetLandLocIDFromDataTable");

	UBaseTaskComponent_GetLandLocIDFromDataTable_Params params;
	params.InTargetName = InTargetName;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.FireEvent
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskEventType>    TaskEventType                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            Param                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ExtMsg                         (Parm, ZeroConstructor)

void UBaseTaskComponent::FireEvent(TEnumAsByte<ETaskEventType> TaskEventType, int Param, const struct FString& ExtMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.FireEvent");

	UBaseTaskComponent_FireEvent_Params params;
	params.TaskEventType = TaskEventType;
	params.Param = Param;
	params.ExtMsg = ExtMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.DeactiveCondition
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> InTaskConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::DeactiveCondition(TEnumAsByte<ETaskConditionType> InTaskConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.DeactiveCondition");

	UBaseTaskComponent_DeactiveCondition_Params params;
	params.InTaskConditionType = InTaskConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.CreateTriggerObject
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskType>         TaskType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UUAETriggerObject_Task*  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UUAETriggerObject_Task* UBaseTaskComponent::CreateTriggerObject(TEnumAsByte<ETaskType> TaskType, int TaskID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.CreateTriggerObject");

	UBaseTaskComponent_CreateTriggerObject_Params params;
	params.TaskType = TaskType;
	params.TaskID = TaskID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.AddTrigger
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskType>         TaskType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ext_info                       (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UBaseTaskComponent::AddTrigger(TEnumAsByte<ETaskType> TaskType, int TaskID, int process, const struct FString& ext_info)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.AddTrigger");

	UBaseTaskComponent_AddTrigger_Params params;
	params.TaskType = TaskType;
	params.TaskID = TaskID;
	params.process = process;
	params.ext_info = ext_info;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BaseTaskComponent.AddEventToTrigger
// (Final, Native, Protected)
// Parameters:
// class UUAETriggerObject*       TriggerObj                     (Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  Event                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETaskEventType>    TaskEventType                  (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::AddEventToTrigger(class UUAETriggerObject* TriggerObj, class UClass* Event, TEnumAsByte<ETaskEventType> TaskEventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.AddEventToTrigger");

	UBaseTaskComponent_AddEventToTrigger_Params params;
	params.TriggerObj = TriggerObj;
	params.Event = Event;
	params.TaskEventType = TaskEventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BaseTaskComponent.ActiveCondition
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> InTaskConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)

void UBaseTaskComponent::ActiveCondition(TEnumAsByte<ETaskConditionType> InTaskConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BaseTaskComponent.ActiveCondition");

	UBaseTaskComponent_ActiveCondition_Params params;
	params.InTaskConditionType = InTaskConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyaleGameModeBase.SpawnAI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void ABattleRoyaleGameModeBase::SpawnAI(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyaleGameModeBase.SpawnAI");

	ABattleRoyaleGameModeBase_SpawnAI_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyaleGameModeBase.IsClassicBattleResult
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ABattleRoyaleGameModeBase::IsClassicBattleResult()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyaleGameModeBase.IsClassicBattleResult");

	ABattleRoyaleGameModeBase_IsClassicBattleResult_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyaleGameModeBase.GetPlane
// (Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ABattleRoyaleGameModeBase::GetPlane(class APlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyaleGameModeBase.GetPlane");

	ABattleRoyaleGameModeBase_GetPlane_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyaleGameModeBase.CheckMatchGoalAchieved
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ABattleRoyaleGameModeBase::CheckMatchGoalAchieved()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyaleGameModeBase.CheckMatchGoalAchieved");

	ABattleRoyaleGameModeBase_CheckMatchGoalAchieved_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyaleGameMode.GetChallengeLevelRules
// (Final, Native, Public)
// Parameters:
// class UChallengeLevelRules*    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UChallengeLevelRules* ABattleRoyaleGameMode::GetChallengeLevelRules()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyaleGameMode.GetChallengeLevelRules");

	ABattleRoyaleGameMode_GetChallengeLevelRules_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SyncAirplaneRoute
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 StartLoc                       (Parm, IsPlainOldData)
// struct FVector                 StopLoc                        (Parm, IsPlainOldData)
// struct FVector                 CanJumpLoc                     (Parm, IsPlainOldData)
// struct FVector                 ForceJumpLoc                   (Parm, IsPlainOldData)

void ASTExtraGameStateBase::SyncAirplaneRoute(const struct FVector& StartLoc, const struct FVector& StopLoc, const struct FVector& CanJumpLoc, const struct FVector& ForceJumpLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SyncAirplaneRoute");

	ASTExtraGameStateBase_SyncAirplaneRoute_Params params;
	params.StartLoc = StartLoc;
	params.StopLoc = StopLoc;
	params.CanJumpLoc = CanJumpLoc;
	params.ForceJumpLoc = ForceJumpLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.StopAirAttack
// (Final, Native, Public)

void ASTExtraGameStateBase::StopAirAttack()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.StopAirAttack");

	ASTExtraGameStateBase_StopAirAttack_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SimulateAirAttackOver
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)

void ASTExtraGameStateBase::SimulateAirAttackOver()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SimulateAirAttackOver");

	ASTExtraGameStateBase_SimulateAirAttackOver_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetTagCulling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsUse                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::SetTagCulling(bool IsUse)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetTagCulling");

	ASTExtraGameStateBase_SetTagCulling_Params params;
	params.IsUse = IsUse;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetReConnectGameStateInfo
// (Final, Native, Public)
// Parameters:
// struct FReConnectGameStateInfo ReConnectInfo                  (Parm)

void ASTExtraGameStateBase::SetReConnectGameStateInfo(const struct FReConnectGameStateInfo& ReConnectInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetReConnectGameStateInfo");

	ASTExtraGameStateBase_SetReConnectGameStateInfo_Params params;
	params.ReConnectInfo = ReConnectInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetIsFireworksActOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::SetIsFireworksActOpen(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetIsFireworksActOpen");

	ASTExtraGameStateBase_SetIsFireworksActOpen_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetHZB
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::SetHZB(int Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetHZB");

	ASTExtraGameStateBase_SetHZB_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetCurAirAttackWave
// (Final, Native, Public)
// Parameters:
// int                            AirAttackWave                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::SetCurAirAttackWave(int AirAttackWave)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetCurAirAttackWave");

	ASTExtraGameStateBase_SetCurAirAttackWave_Params params;
	params.AirAttackWave = AirAttackWave;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetCurAirAttackType
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EAirAttackInfo>    airattacktype                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::SetCurAirAttackType(TEnumAsByte<EAirAttackInfo> airattacktype)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetCurAirAttackType");

	ASTExtraGameStateBase_SetCurAirAttackType_Params params;
	params.airattacktype = airattacktype;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneStopLoc
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 StopLoc                        (Parm, IsPlainOldData)

void ASTExtraGameStateBase::SetAirplaneStopLoc(const struct FVector& StopLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneStopLoc");

	ASTExtraGameStateBase_SetAirplaneStopLoc_Params params;
	params.StopLoc = StopLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneStartLoc
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 StarLoc                        (Parm, IsPlainOldData)

void ASTExtraGameStateBase::SetAirplaneStartLoc(const struct FVector& StarLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneStartLoc");

	ASTExtraGameStateBase_SetAirplaneStartLoc_Params params;
	params.StarLoc = StarLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneForceJumpLoc
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 ForceJumpLoc                   (Parm, IsPlainOldData)

void ASTExtraGameStateBase::SetAirplaneForceJumpLoc(const struct FVector& ForceJumpLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneForceJumpLoc");

	ASTExtraGameStateBase_SetAirplaneForceJumpLoc_Params params;
	params.ForceJumpLoc = ForceJumpLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneCanJumpLoc
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 CanJumpLoc                     (Parm, IsPlainOldData)

void ASTExtraGameStateBase::SetAirplaneCanJumpLoc(const struct FVector& CanJumpLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.SetAirplaneCanJumpLoc");

	ASTExtraGameStateBase_SetAirplaneCanJumpLoc_Params params;
	params.CanJumpLoc = CanJumpLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_StartedPlane
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_StartedPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_StartedPlane");

	ASTExtraGameStateBase_OnRep_StartedPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ReadyStateTime
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_ReadyStateTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ReadyStateTime");

	ASTExtraGameStateBase_OnRep_ReadyStateTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ReadyStateCountingDown
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_ReadyStateCountingDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ReadyStateCountingDown");

	ASTExtraGameStateBase_OnRep_ReadyStateCountingDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_PlayerNumOnPlane
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_PlayerNumOnPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_PlayerNumOnPlane");

	ASTExtraGameStateBase_OnRep_PlayerNumOnPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_PlayerNumChange
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_PlayerNumChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_PlayerNumChange");

	ASTExtraGameStateBase_OnRep_PlayerNumChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ModeUIManagerArray
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_ModeUIManagerArray()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_ModeUIManagerArray");

	ASTExtraGameStateBase_OnRep_ModeUIManagerArray_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_LobbyGameType
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_LobbyGameType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_LobbyGameType");

	ASTExtraGameStateBase_OnRep_LobbyGameType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsTrainingMode
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_IsTrainingMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsTrainingMode");

	ASTExtraGameStateBase_OnRep_IsTrainingMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsShowDeadBox
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_IsShowDeadBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsShowDeadBox");

	ASTExtraGameStateBase_OnRep_IsShowDeadBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsFPPMode
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_IsFPPMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsFPPMode");

	ASTExtraGameStateBase_OnRep_IsFPPMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsFireworksActOpen
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_IsFireworksActOpen()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsFireworksActOpen");

	ASTExtraGameStateBase_OnRep_IsFireworksActOpen_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsDark
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_IsDark()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_IsDark");

	ASTExtraGameStateBase_OnRep_IsDark_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameTerminatorPlayerKey
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_GameTerminatorPlayerKey()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameTerminatorPlayerKey");

	ASTExtraGameStateBase_OnRep_GameTerminatorPlayerKey_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameModeType
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_GameModeType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameModeType");

	ASTExtraGameStateBase_OnRep_GameModeType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameModeState
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_GameModeState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_GameModeState");

	ASTExtraGameStateBase_OnRep_GameModeState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_FinalWinTeams
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_FinalWinTeams()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_FinalWinTeams");

	ASTExtraGameStateBase_OnRep_FinalWinTeams_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_FinalWinPlayers
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_FinalWinPlayers()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_FinalWinPlayers");

	ASTExtraGameStateBase_OnRep_FinalWinPlayers_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AliveTeamNum
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AliveTeamNum()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AliveTeamNum");

	ASTExtraGameStateBase_OnRep_AliveTeamNum_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AlivePlayerNum
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AlivePlayerNum()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AlivePlayerNum");

	ASTExtraGameStateBase_OnRep_AlivePlayerNum_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneStopLoc
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AirplaneStopLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneStopLoc");

	ASTExtraGameStateBase_OnRep_AirplaneStopLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneStartLoc
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AirplaneStartLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneStartLoc");

	ASTExtraGameStateBase_OnRep_AirplaneStartLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneForceJumpLoc
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AirplaneForceJumpLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneForceJumpLoc");

	ASTExtraGameStateBase_OnRep_AirplaneForceJumpLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneCanJumpLoc
// (Final, Native, Public)

void ASTExtraGameStateBase::OnRep_AirplaneCanJumpLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnRep_AirplaneCanJumpLoc");

	ASTExtraGameStateBase_OnRep_AirplaneCanJumpLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.OnGameModeDisplayNameChange
// (Final, Native, Protected)

void ASTExtraGameStateBase::OnGameModeDisplayNameChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.OnGameModeDisplayNameChange");

	ASTExtraGameStateBase_OnGameModeDisplayNameChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.IsPlaneValid
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraGameStateBase::IsPlaneValid()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.IsPlaneValid");

	ASTExtraGameStateBase_IsPlaneValid_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.IsMapUseTeamPattern
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraGameStateBase::IsMapUseTeamPattern()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.IsMapUseTeamPattern");

	ASTExtraGameStateBase_IsMapUseTeamPattern_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetRepServerWorldTimeSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraGameStateBase::GetRepServerWorldTimeSeconds()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetRepServerWorldTimeSeconds");

	ASTExtraGameStateBase_GetRepServerWorldTimeSeconds_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetReConnectGameStateInfo
// (Native, Public)
// Parameters:
// struct FReConnectGameStateInfo ReturnValue                    (Parm, OutParm, ReturnParm)

struct FReConnectGameStateInfo ASTExtraGameStateBase::GetReConnectGameStateInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetReConnectGameStateInfo");

	ASTExtraGameStateBase_GetReConnectGameStateInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetIsFireworksActOpen
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraGameStateBase::GetIsFireworksActOpen()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetIsFireworksActOpen");

	ASTExtraGameStateBase_GetIsFireworksActOpen_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetGameModeState
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraGameStateBase::GetGameModeState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetGameModeState");

	ASTExtraGameStateBase_GetGameModeState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetForceJumpLoc
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraGameStateBase::GetForceJumpLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetForceJumpLoc");

	ASTExtraGameStateBase_GetForceJumpLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetCurCircleWave
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraGameStateBase::GetCurCircleWave()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetCurCircleWave");

	ASTExtraGameStateBase_GetCurCircleWave_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetCurCircleState
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ECircleInfo>       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ECircleInfo> ASTExtraGameStateBase::GetCurCircleState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetCurCircleState");

	ASTExtraGameStateBase_GetCurCircleState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetCanJumpLoc
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraGameStateBase::GetCanJumpLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetCanJumpLoc");

	ASTExtraGameStateBase_GetCanJumpLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetAirplaneStopLoc
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraGameStateBase::GetAirplaneStopLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetAirplaneStopLoc");

	ASTExtraGameStateBase_GetAirplaneStopLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.GetAirplaneStartLoc
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraGameStateBase::GetAirplaneStartLoc()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.GetAirplaneStartLoc");

	ASTExtraGameStateBase_GetAirplaneStartLoc_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.ChangeWeatherStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FWeatherChangeEvent     Event                          (Parm, IsPlainOldData)

void ASTExtraGameStateBase::ChangeWeatherStatus(const struct FWeatherChangeEvent& Event)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.ChangeWeatherStatus");

	ASTExtraGameStateBase_ChangeWeatherStatus_Params params;
	params.Event = Event;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastRoute
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 StartLoc                       (Parm, IsPlainOldData)
// struct FVector                 StopLoc                        (Parm, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastRoute(const struct FVector& StartLoc, const struct FVector& StopLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastRoute");

	ASTExtraGameStateBase_BroadcastRoute_Params params;
	params.StartLoc = StartLoc;
	params.StopLoc = StopLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleWaveOver
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastCircleWaveOver(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleWaveOver");

	ASTExtraGameStateBase_BroadcastCircleWaveOver_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleSizeAndPosition
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 BlueCircleSync                 (Parm, IsPlainOldData)
// struct FVector                 WhiteCircleSync                (Parm, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           InbActiveScreenSize            (Parm, ZeroConstructor, IsPlainOldData)
// float                          InScreenSizeFactor             (Parm, ZeroConstructor, IsPlainOldData)
// float                          InExtraRadius                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastCircleSizeAndPosition(const struct FVector& BlueCircleSync, const struct FVector& WhiteCircleSync, int Index, bool InbActiveScreenSize, float InScreenSizeFactor, float InExtraRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleSizeAndPosition");

	ASTExtraGameStateBase_BroadcastCircleSizeAndPosition_Params params;
	params.BlueCircleSync = BlueCircleSync;
	params.WhiteCircleSync = WhiteCircleSync;
	params.Index = Index;
	params.InbActiveScreenSize = InbActiveScreenSize;
	params.InScreenSizeFactor = InScreenSizeFactor;
	params.InExtraRadius = InExtraRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleInfo
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, NetValidate)
// Parameters:
// TEnumAsByte<ECircleInfo>       circleInfo                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 BlueCircleSync                 (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 WhiteCircleSync                (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// int                            CircleInvertedIndex            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastCircleInfo(TEnumAsByte<ECircleInfo> circleInfo, float Time, const struct FVector& BlueCircleSync, const struct FVector& WhiteCircleSync, int CircleInvertedIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastCircleInfo");

	ASTExtraGameStateBase_BroadcastCircleInfo_Params params;
	params.circleInfo = circleInfo;
	params.Time = Time;
	params.BlueCircleSync = BlueCircleSync;
	params.WhiteCircleSync = WhiteCircleSync;
	params.CircleInvertedIndex = CircleInvertedIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastAirAttackWarning
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 airAttackAreaSrc               (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// int                            waveindex                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastAirAttackWarning(const struct FVector& airAttackAreaSrc, int waveindex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastAirAttackWarning");

	ASTExtraGameStateBase_BroadcastAirAttackWarning_Params params;
	params.airAttackAreaSrc = airAttackAreaSrc;
	params.waveindex = waveindex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastAirAttackOrder
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// struct FAirAttackOrder         airAttackOrderSrc              (ConstParm, Parm, ReferenceParm)
// int                            waveindex                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraGameStateBase::BroadcastAirAttackOrder(const struct FAirAttackOrder& airAttackOrderSrc, int waveindex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameStateBase.BroadcastAirAttackOrder");

	ASTExtraGameStateBase_BroadcastAirAttackOrder_Params params;
	params.airAttackOrderSrc = airAttackOrderSrc;
	params.waveindex = waveindex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.ReCalculateCorpsDetailList
// (Final, Native, Public)
// Parameters:
// bool                           bForceOutGame                  (Parm, ZeroConstructor, IsPlainOldData)

void ABattleRoyalCorpsWarGameState::ReCalculateCorpsDetailList(bool bForceOutGame)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.ReCalculateCorpsDetailList");

	ABattleRoyalCorpsWarGameState_ReCalculateCorpsDetailList_Params params;
	params.bForceOutGame = bForceOutGame;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepOutGameCorpsDetailList
// (Final, Native, Protected)

void ABattleRoyalCorpsWarGameState::OnRepOutGameCorpsDetailList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepOutGameCorpsDetailList");

	ABattleRoyalCorpsWarGameState_OnRepOutGameCorpsDetailList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepCorpsInfoArray
// (Final, Native, Protected)

void ABattleRoyalCorpsWarGameState::OnRepCorpsInfoArray()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepCorpsInfoArray");

	ABattleRoyalCorpsWarGameState_OnRepCorpsInfoArray_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepCachedSortedCorpsDetailList
// (Final, Native, Protected)

void ABattleRoyalCorpsWarGameState::OnRepCachedSortedCorpsDetailList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnRepCachedSortedCorpsDetailList");

	ABattleRoyalCorpsWarGameState_OnRepCachedSortedCorpsDetailList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnCorpsOutGame
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            KillerCorpsID                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            CorpsID                        (Parm, ZeroConstructor, IsPlainOldData)

void ABattleRoyalCorpsWarGameState::OnCorpsOutGame(int KillerCorpsID, int CorpsID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnCorpsOutGame");

	ABattleRoyalCorpsWarGameState_OnCorpsOutGame_Params params;
	params.KillerCorpsID = KillerCorpsID;
	params.CorpsID = CorpsID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnCorpsJoinGame
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            CorpsID                        (Parm, ZeroConstructor, IsPlainOldData)

void ABattleRoyalCorpsWarGameState::OnCorpsJoinGame(int CorpsID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.OnCorpsJoinGame");

	ABattleRoyalCorpsWarGameState_OnCorpsJoinGame_Params params;
	params.CorpsID = CorpsID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetTotalCorpsNums
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ABattleRoyalCorpsWarGameState::GetTotalCorpsNums()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetTotalCorpsNums");

	ABattleRoyalCorpsWarGameState_GetTotalCorpsNums_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetSortedCorpsDetailList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FCorpsDetailInfo> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FCorpsDetailInfo> ABattleRoyalCorpsWarGameState::GetSortedCorpsDetailList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetSortedCorpsDetailList");

	ABattleRoyalCorpsWarGameState_GetSortedCorpsDetailList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetPlayerLiveTime
// (Final, Native, Protected)
// Parameters:
// class ABattleRoyalCorpsWarPlayerState* State                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ABattleRoyalCorpsWarGameState::GetPlayerLiveTime(class ABattleRoyalCorpsWarPlayerState* State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetPlayerLiveTime");

	ABattleRoyalCorpsWarGameState_GetPlayerLiveTime_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetCorpsInfoByID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FCorpsBaseInfo          ReturnValue                    (Parm, OutParm, ReturnParm)

struct FCorpsBaseInfo ABattleRoyalCorpsWarGameState::GetCorpsInfoByID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetCorpsInfoByID");

	ABattleRoyalCorpsWarGameState_GetCorpsInfoByID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetActiveCorpsNum
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ABattleRoyalCorpsWarGameState::GetActiveCorpsNum()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.GetActiveCorpsNum");

	ABattleRoyalCorpsWarGameState_GetActiveCorpsNum_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.ForceFlushList
// (Final, Native, Protected)

void ABattleRoyalCorpsWarGameState::ForceFlushList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BattleRoyalCorpsWarGameState.ForceFlushList");

	ABattleRoyalCorpsWarGameState_ForceFlushList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.SetForceSyncTeammateData
// (Final, Native, Public)
// Parameters:
// bool                           IsForCE                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::SetForceSyncTeammateData(bool IsForCE)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.SetForceSyncTeammateData");

	ASTExtraPlayerState_SetForceSyncTeammateData_Params params;
	params.IsForCE = IsForCE;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.RetriveCampPlayerStateListOnClient
// (Final, Native, Public)
// Parameters:
// TArray<TWeakObjectPtr<class ASTExtraPlayerState>> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<TWeakObjectPtr<class ASTExtraPlayerState>> ASTExtraPlayerState::RetriveCampPlayerStateListOnClient()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.RetriveCampPlayerStateListOnClient");

	ASTExtraPlayerState_RetriveCampPlayerStateListOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnRescueingStatusChange
// (Final, Native, Public)
// Parameters:
// class ACharacter*              _helpWho                       (Parm, ZeroConstructor, IsPlainOldData)
// class ACharacter*              _ownerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurningInto                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingRescueTime            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsFirstPlayerHelper            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::RespondToPawnRescueingStatusChange(class ACharacter* _helpWho, class ACharacter* _ownerPawn, bool IsTurningInto, float RemainingRescueTime, bool IsFirstPlayerHelper)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnRescueingStatusChange");

	ASTExtraPlayerState_RespondToPawnRescueingStatusChange_Params params;
	params._helpWho = _helpWho;
	params._ownerPawn = _ownerPawn;
	params.IsTurningInto = IsTurningInto;
	params.RemainingRescueTime = RemainingRescueTime;
	params.IsFirstPlayerHelper = IsFirstPlayerHelper;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnCanRescueOtherStatusChange
// (Final, Native, Public)
// Parameters:
// class ASTExtraBaseCharacter*   _helpWho                       (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   _ownerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurningInto                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::RespondToPawnCanRescueOtherStatusChange(class ASTExtraBaseCharacter* _helpWho, class ASTExtraBaseCharacter* _ownerPawn, bool IsTurningInto)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnCanRescueOtherStatusChange");

	ASTExtraPlayerState_RespondToPawnCanRescueOtherStatusChange_Params params;
	params._helpWho = _helpWho;
	params._ownerPawn = _ownerPawn;
	params.IsTurningInto = IsTurningInto;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnBreathChange
// (Final, Native, Public)
// Parameters:
// float                          _health                        (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterHealthStatus> _healthStatus                  (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   Param2                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::RespondToPawnBreathChange(float _health, TEnumAsByte<ECharacterHealthStatus> _healthStatus, class ASTExtraBaseCharacter* Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.RespondToPawnBreathChange");

	ASTExtraPlayerState_RespondToPawnBreathChange_Params params;
	params._health = _health;
	params._healthStatus = _healthStatus;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.RefreshFollowMark
// (Final, Native, Public)

void ASTExtraPlayerState::RefreshFollowMark()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.RefreshFollowMark");

	ASTExtraPlayerState_RefreshFollowMark_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.PlayersCountOnMyPlane
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerState::PlayersCountOnMyPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.PlayersCountOnMyPlane");

	ASTExtraPlayerState_PlayersCountOnMyPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_TeamMatePlayerStateList
// (Native, Public)

void ASTExtraPlayerState::OnRep_TeamMatePlayerStateList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_TeamMatePlayerStateList");

	ASTExtraPlayerState_OnRep_TeamMatePlayerStateList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_TeamMatePlayerStateIndex
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_TeamMatePlayerStateIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_TeamMatePlayerStateIndex");

	ASTExtraPlayerState_OnRep_TeamMatePlayerStateIndex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_RankNotify
// (Native, Public)

void ASTExtraPlayerState::OnRep_RankNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_RankNotify");

	ASTExtraPlayerState_OnRep_RankNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayersCountOnPlane
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayersCountOnPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayersCountOnPlane");

	ASTExtraPlayerState_OnRep_PlayersCountOnPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerReconnectEvent
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayerReconnectEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerReconnectEvent");

	ASTExtraPlayerState_OnRep_PlayerReconnectEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerName
// (Native, Public)

void ASTExtraPlayerState::OnRep_PlayerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerName");

	ASTExtraPlayerState_OnRep_PlayerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerLostConnectionEvent
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayerLostConnectionEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerLostConnectionEvent");

	ASTExtraPlayerState_OnRep_PlayerLostConnectionEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerLiveState
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayerLiveState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerLiveState");

	ASTExtraPlayerState_OnRep_PlayerLiveState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerKillsChange
// (Native, Public)

void ASTExtraPlayerState::OnRep_PlayerKillsChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerKillsChange");

	ASTExtraPlayerState_OnRep_PlayerKillsChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerIsFollowing
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayerIsFollowing()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerIsFollowing");

	ASTExtraPlayerState_OnRep_PlayerIsFollowing_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerExitGameEvent
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_PlayerExitGameEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_PlayerExitGameEvent");

	ASTExtraPlayerState_OnRep_PlayerExitGameEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_MapMarkNotify
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_MapMarkNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_MapMarkNotify");

	ASTExtraPlayerState_OnRep_MapMarkNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_HPChanged
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_HPChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_HPChanged");

	ASTExtraPlayerState_OnRep_HPChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_BreathChanged
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_BreathChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_BreathChanged");

	ASTExtraPlayerState_OnRep_BreathChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.OnRep_BPS
// (Final, Native, Public)

void ASTExtraPlayerState::OnRep_BPS()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.OnRep_BPS");

	ASTExtraPlayerState_OnRep_BPS_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerState.OnPlayerKillsChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerState::OnPlayerKillsChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerState.OnPlayerKillsChangeDelegate__DelegateSignature");

	ASTExtraPlayerState_OnPlayerKillsChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerState.OnLocalCharacterHPChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          currentHP                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ratioHP                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::OnLocalCharacterHPChangeDelegate__DelegateSignature(float currentHP, float ratioHP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerState.OnLocalCharacterHPChangeDelegate__DelegateSignature");

	ASTExtraPlayerState_OnLocalCharacterHPChangeDelegate__DelegateSignature_Params params;
	params.currentHP = currentHP;
	params.ratioHP = ratioHP;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.IsSinglePlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerState::IsSinglePlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.IsSinglePlayer");

	ASTExtraPlayerState_IsSinglePlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.IsAlive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerState::IsAlive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.IsAlive");

	ASTExtraPlayerState_IsAlive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetUserIDByMemberID
// (Native, Public)
// Parameters:
// int                            memberID                       (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

uint32_t ASTExtraPlayerState::GetUserIDByMemberID(int memberID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetUserIDByMemberID");

	ASTExtraPlayerState_GetUserIDByMemberID_Params params;
	params.memberID = memberID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetTeamMatePlayerStateList
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class ASTExtraPlayerState*> OutList                        (Parm, OutParm, ZeroConstructor)
// bool                           ExcludeMyself                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::GetTeamMatePlayerStateList(bool ExcludeMyself, TArray<class ASTExtraPlayerState*>* OutList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetTeamMatePlayerStateList");

	ASTExtraPlayerState_GetTeamMatePlayerStateList_Params params;
	params.ExcludeMyself = ExcludeMyself;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutList != nullptr)
		*OutList = params.OutList;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetTeamMateIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerState*     Teammate                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerState::GetTeamMateIndex(class ASTExtraPlayerState* Teammate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetTeamMateIndex");

	ASTExtraPlayerState_GetTeamMateIndex_Params params;
	params.Teammate = Teammate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetTeammateByName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 TeammateName                   (Parm, ZeroConstructor)
// class ASTExtraPlayerState*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerState* ASTExtraPlayerState::GetTeammateByName(const struct FString& TeammateName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetTeammateByName");

	ASTExtraPlayerState_GetTeammateByName_Params params;
	params.TeammateName = TeammateName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerTemperature
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetPlayerTemperature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerTemperature");

	ASTExtraPlayerState_GetPlayerTemperature_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerTeamIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerState::GetPlayerTeamIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerTeamIndex");

	ASTExtraPlayerState_GetPlayerTeamIndex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerMaxTemperature
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetPlayerMaxTemperature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerMaxTemperature");

	ASTExtraPlayerState_GetPlayerMaxTemperature_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerMaxHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetPlayerMaxHealth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerMaxHealth");

	ASTExtraPlayerState_GetPlayerMaxHealth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerHealthPercent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetPlayerHealthPercent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerHealthPercent");

	ASTExtraPlayerState_GetPlayerHealthPercent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerHealth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetPlayerHealth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerHealth");

	ASTExtraPlayerState_GetPlayerHealth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* ASTExtraPlayerState::GetPlayerCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetPlayerCharacter");

	ASTExtraPlayerState_GetPlayerCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetMaxEnegyBuff
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetMaxEnegyBuff()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetMaxEnegyBuff");

	ASTExtraPlayerState_GetMaxEnegyBuff_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetCampPlayerStateListOnClient
// (Native, Protected, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class ASTExtraPlayerState*> PlayerStateList                (Parm, OutParm, ZeroConstructor)

void ASTExtraPlayerState::GetCampPlayerStateListOnClient(TArray<class ASTExtraPlayerState*>* PlayerStateList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetCampPlayerStateListOnClient");

	ASTExtraPlayerState_GetCampPlayerStateListOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (PlayerStateList != nullptr)
		*PlayerStateList = params.PlayerStateList;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetCampMatePlayerList
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class ASTExtraBaseCharacter*> playerList                     (Parm, OutParm, ZeroConstructor)
// bool                           includeTeammate                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::GetCampMatePlayerList(bool includeTeammate, TArray<class ASTExtraBaseCharacter*>* playerList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetCampMatePlayerList");

	ASTExtraPlayerState_GetCampMatePlayerList_Params params;
	params.includeTeammate = includeTeammate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (playerList != nullptr)
		*playerList = params.playerList;
}


// Function ShadowTrackerExtra.STExtraPlayerState.GetBreathPercentage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerState::GetBreathPercentage()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.GetBreathPercentage");

	ASTExtraPlayerState_GetBreathPercentage_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.ClientDisplayGameTipWithMsgID
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Param1                         (Parm, ZeroConstructor)
// struct FString                 Param2                         (Parm, ZeroConstructor)

void ASTExtraPlayerState::ClientDisplayGameTipWithMsgID(int ID, const struct FString& Param1, const struct FString& Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.ClientDisplayGameTipWithMsgID");

	ASTExtraPlayerState_ClientDisplayGameTipWithMsgID_Params params;
	params.ID = ID;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.ChangeFadeMapMarkDist
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          NewDist                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::ChangeFadeMapMarkDist(float NewDist)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.ChangeFadeMapMarkDist");

	ASTExtraPlayerState_ChangeFadeMapMarkDist_Params params;
	params.NewDist = NewDist;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerState.CalculateEnegyStage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPlayerEnegyStage> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EPlayerEnegyStage> ASTExtraPlayerState::CalculateEnegyStage()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.CalculateEnegyStage");

	ASTExtraPlayerState_CalculateEnegyStage_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerState.AddEnegySafety
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerState::AddEnegySafety(float AddVal)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerState.AddEnegySafety");

	ASTExtraPlayerState_AddEnegySafety_Params params;
	params.AddVal = AddVal;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BoxPickUpListWrapperActor.ModifyPickUpDataList
// (Final, Native, Public)
// Parameters:
// TArray<struct FPickUpItemData> DataList                       (Parm, ZeroConstructor)

void ABoxPickUpListWrapperActor::ModifyPickUpDataList(TArray<struct FPickUpItemData> DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BoxPickUpListWrapperActor.ModifyPickUpDataList");

	ABoxPickUpListWrapperActor_ModifyPickUpDataList_Params params;
	params.DataList = DataList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BoxPickUpListWrapperActor.FinishPickedUp
// (Native, Protected)
// Parameters:
// class AActor*                  OwnerTarget                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void ABoxPickUpListWrapperActor::FinishPickedUp(class AActor* OwnerTarget, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BoxPickUpListWrapperActor.FinishPickedUp");

	ABoxPickUpListWrapperActor_FinishPickedUp_Params params;
	params.OwnerTarget = OwnerTarget;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameModeState.GotoNextState
// (Native, Protected)

void UGameModeState::GotoNextState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameModeState.GotoNextState");

	UGameModeState_GotoNextState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRGameModeTeam_YearBeast.GetBattleFieldRadius
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ABRGameModeTeam_YearBeast::GetBattleFieldRadius()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameModeTeam_YearBeast.GetBattleFieldRadius");

	ABRGameModeTeam_YearBeast_GetBattleFieldRadius_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BRGameModeTeam_YearBeast.GetBattleFieldCenter
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ABRGameModeTeam_YearBeast::GetBattleFieldCenter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameModeTeam_YearBeast.GetBattleFieldCenter");

	ABRGameModeTeam_YearBeast_GetBattleFieldCenter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.SetBeastActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  _beast                         (Parm, ZeroConstructor, IsPlainOldData)

void ABRGameState_YearBeast::SetBeastActor(class AActor* _beast)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.SetBeastActor");

	ABRGameState_YearBeast_SetBeastActor_Params params;
	params._beast = _beast;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.OnRep_WeakBeastActor
// (Final, Native, Private)

void ABRGameState_YearBeast::OnRep_WeakBeastActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.OnRep_WeakBeastActor");

	ABRGameState_YearBeast_OnRep_WeakBeastActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.OnRep_GameEndRemainTime
// (Final, Native, Private)

void ABRGameState_YearBeast::OnRep_GameEndRemainTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.OnRep_GameEndRemainTime");

	ABRGameState_YearBeast_OnRep_GameEndRemainTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.IsMapUseTeamPattern
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ABRGameState_YearBeast::IsMapUseTeamPattern()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.IsMapUseTeamPattern");

	ABRGameState_YearBeast_IsMapUseTeamPattern_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.GetBeastActor
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           Success                        (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ABRGameState_YearBeast::GetBeastActor(bool* Success)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.GetBeastActor");

	ABRGameState_YearBeast_GetBeastActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (Success != nullptr)
		*Success = params.Success;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.BroadcastYearBeastSkillWarning
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// unsigned char                  _skillID                       (Parm, ZeroConstructor, IsPlainOldData)

void ABRGameState_YearBeast::BroadcastYearBeastSkillWarning(unsigned char _skillID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.BroadcastYearBeastSkillWarning");

	ABRGameState_YearBeast_BroadcastYearBeastSkillWarning_Params params;
	params._skillID = _skillID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRGameState_YearBeast.BroadcastYearBeastGameFlowMessage
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// EGameFlowCheckPointType        InMessageType                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            RefreshTime                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            RemainTime                     (Parm, ZeroConstructor, IsPlainOldData)

void ABRGameState_YearBeast::BroadcastYearBeastGameFlowMessage(EGameFlowCheckPointType InMessageType, int RefreshTime, int RemainTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRGameState_YearBeast.BroadcastYearBeastGameFlowMessage");

	ABRGameState_YearBeast_BroadcastYearBeastGameFlowMessage_Params params;
	params.InMessageType = InMessageType;
	params.RefreshTime = RefreshTime;
	params.RemainTime = RemainTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.SortCampPlayerListByRank
// (Final, Native, Public)

void ABRPlayerState_YearBeast::SortCampPlayerListByRank()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.SortCampPlayerListByRank");

	ABRPlayerState_YearBeast_SortCampPlayerListByRank_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.RegistSelfToLocalPlayerState
// (Final, Native, Private)

void ABRPlayerState_YearBeast::RegistSelfToLocalPlayerState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.RegistSelfToLocalPlayerState");

	ABRPlayerState_YearBeast_RegistSelfToLocalPlayerState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.RecollectAllLocalPlayerState
// (Final, Native, Protected)

void ABRPlayerState_YearBeast::RecollectAllLocalPlayerState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.RecollectAllLocalPlayerState");

	ABRPlayerState_YearBeast_RecollectAllLocalPlayerState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_RankNotify
// (Native, Protected)

void ABRPlayerState_YearBeast::OnRep_RankNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_RankNotify");

	ABRPlayerState_YearBeast_OnRep_RankNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_PlayerRespawnRemainTime
// (Final, Native, Public)

void ABRPlayerState_YearBeast::OnRep_PlayerRespawnRemainTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_PlayerRespawnRemainTime");

	ABRPlayerState_YearBeast_OnRep_PlayerRespawnRemainTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_DamageAmountToYearBeast
// (Final, Native, Public)

void ABRPlayerState_YearBeast::OnRep_DamageAmountToYearBeast()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.OnRep_DamageAmountToYearBeast");

	ABRPlayerState_YearBeast_OnRep_DamageAmountToYearBeast_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnPlayerStateRespawnCDChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ABRPlayerState_YearBeast::OnPlayerStateRespawnCDChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnPlayerStateRespawnCDChangeDelegate__DelegateSignature");

	ABRPlayerState_YearBeast_OnPlayerStateRespawnCDChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnPlayerStateDamageAmountChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ABRPlayerState_YearBeast::OnPlayerStateDamageAmountChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnPlayerStateDamageAmountChangeDelegate__DelegateSignature");

	ABRPlayerState_YearBeast_OnPlayerStateDamageAmountChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnCampHasNewPlayerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ABRPlayerState_YearBeast::OnCampHasNewPlayerDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.BRPlayerState_YearBeast.OnCampHasNewPlayerDelegate__DelegateSignature");

	ABRPlayerState_YearBeast_OnCampHasNewPlayerDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.GetSortedTeamPlayerStateList
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class ABRPlayerState_YearBeast*> PlayerStateList                (Parm, OutParm, ZeroConstructor)

void ABRPlayerState_YearBeast::GetSortedTeamPlayerStateList(TArray<class ABRPlayerState_YearBeast*>* PlayerStateList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.GetSortedTeamPlayerStateList");

	ABRPlayerState_YearBeast_GetSortedTeamPlayerStateList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (PlayerStateList != nullptr)
		*PlayerStateList = params.PlayerStateList;
}


// Function ShadowTrackerExtra.BRPlayerState_YearBeast.GetSortedCampPlayerStateList
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class ABRPlayerState_YearBeast*> PlayerStateList                (Parm, OutParm, ZeroConstructor)

void ABRPlayerState_YearBeast::GetSortedCampPlayerStateList(TArray<class ABRPlayerState_YearBeast*>* PlayerStateList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BRPlayerState_YearBeast.GetSortedCampPlayerStateList");

	ABRPlayerState_YearBeast_GetSortedCampPlayerStateList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (PlayerStateList != nullptr)
		*PlayerStateList = params.PlayerStateList;
}


// Function ShadowTrackerExtra.BTTask_SetYearBeastStateBase.ReceiveTaskFinishedAI
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                  OwnerActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   ControlledPawn                 (Parm, ZeroConstructor, IsPlainOldData)

void UBTTask_SetYearBeastStateBase::ReceiveTaskFinishedAI(class AActor* OwnerActor, class APawn* ControlledPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BTTask_SetYearBeastStateBase.ReceiveTaskFinishedAI");

	UBTTask_SetYearBeastStateBase_ReceiveTaskFinishedAI_Params params;
	params.OwnerActor = OwnerActor;
	params.ControlledPawn = ControlledPawn;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BTTask_SetYearBeastStateBase.ReceiveTaskFinished
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                  OwnerActor                     (Parm, ZeroConstructor, IsPlainOldData)

void UBTTask_SetYearBeastStateBase::ReceiveTaskFinished(class AActor* OwnerActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BTTask_SetYearBeastStateBase.ReceiveTaskFinished");

	UBTTask_SetYearBeastStateBase_ReceiveTaskFinished_Params params;
	params.OwnerActor = OwnerActor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletHitInfoUploadComponent.HandleOnWeaponStopFire
// (Final, Native, Protected)

void UBulletHitInfoUploadComponent::HandleOnWeaponStopFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletHitInfoUploadComponent.HandleOnWeaponStopFire");

	UBulletHitInfoUploadComponent_HandleOnWeaponStopFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletHitInfoUploadComponent.HandleOnWeaponStartFire
// (Final, Native, Protected)

void UBulletHitInfoUploadComponent::HandleOnWeaponStartFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletHitInfoUploadComponent.HandleOnWeaponStartFire");

	UBulletHitInfoUploadComponent_HandleOnWeaponStartFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletHitInfoUploadComponent.AddHitData
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FBulletHitInfoUploadData Data                           (ConstParm, Parm, OutParm, ReferenceParm)
// struct FLocalShootHitData      ShootData                      (ConstParm, Parm, OutParm, ReferenceParm)

void UBulletHitInfoUploadComponent::AddHitData(const struct FBulletHitInfoUploadData& Data, const struct FLocalShootHitData& ShootData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletHitInfoUploadComponent.AddHitData");

	UBulletHitInfoUploadComponent_AddHitData_Params params;
	params.Data = Data;
	params.ShootData = ShootData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletMovementComponent.ResumeMoveAfterImpactWithNoLost
// (Final, Native, Public, BlueprintCallable)

void UBulletMovementComponent::ResumeMoveAfterImpactWithNoLost()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletMovementComponent.ResumeMoveAfterImpactWithNoLost");

	UBulletMovementComponent_ResumeMoveAfterImpactWithNoLost_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletMovementComponent.ResetTickDelay
// (Final, Native, Public, BlueprintCallable)

void UBulletMovementComponent::ResetTickDelay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletMovementComponent.ResetTickDelay");

	UBulletMovementComponent_ResetTickDelay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletMovementComponent.ForceStop
// (Final, Native, Public, BlueprintCallable)

void UBulletMovementComponent::ForceStop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletMovementComponent.ForceStop");

	UBulletMovementComponent_ForceStop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponStopFire
// (Final, Native, Public, BlueprintCallable)

void UBulletTrackComponent::OnWeaponStopFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponStopFire");

	UBulletTrackComponent_OnWeaponStopFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponStartFire
// (Final, Native, Public, BlueprintCallable)

void UBulletTrackComponent::OnWeaponStartFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponStartFire");

	UBulletTrackComponent_OnWeaponStartFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponShoot
// (Final, Native, Public, BlueprintCallable)

void UBulletTrackComponent::OnWeaponShoot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletTrackComponent.OnWeaponShoot");

	UBulletTrackComponent_OnWeaponShoot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.BulletTrackComponent.GetCurRecoilInfo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector UBulletTrackComponent::GetCurRecoilInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletTrackComponent.GetCurRecoilInfo");

	UBulletTrackComponent_GetCurRecoilInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.BulletTrackComponent.GetCurDeviation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UBulletTrackComponent::GetCurDeviation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.BulletTrackComponent.GetCurDeviation");

	UBulletTrackComponent_GetCurDeviation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CameraSettingComponentFromBP.SaveCurCameraSetting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USpringArmComponent*     SpringArm                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UCameraSettingComponentFromBP::SaveCurCameraSetting(class USpringArmComponent* SpringArm)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CameraSettingComponentFromBP.SaveCurCameraSetting");

	UCameraSettingComponentFromBP_SaveCurCameraSetting_Params params;
	params.SpringArm = SpringArm;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CameraSettingComponentFromBP.LerpCameraSettings
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// float                          LerpAlpha                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FCameraSettings         CameraSetting                  (Parm, OutParm)
// class USpringArmComponent*     SpringArm                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UCameraSettingComponentFromBP::LerpCameraSettings(float LerpAlpha, class USpringArmComponent* SpringArm, struct FCameraSettings* CameraSetting)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CameraSettingComponentFromBP.LerpCameraSettings");

	UCameraSettingComponentFromBP_LerpCameraSettings_Params params;
	params.LerpAlpha = LerpAlpha;
	params.SpringArm = SpringArm;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (CameraSetting != nullptr)
		*CameraSetting = params.CameraSetting;
}


// Function ShadowTrackerExtra.CampmateWidget.SetBaseCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   BC                             (Parm, ZeroConstructor, IsPlainOldData)

void UCampmateWidget::SetBaseCharacter(class ASTExtraBaseCharacter* BC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CampmateWidget.SetBaseCharacter");

	UCampmateWidget_SetBaseCharacter_Params params;
	params.BC = BC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChallengeLevelRules.SpawnLevelDirector
// (Native, Public)
// Parameters:
// class UClass*                  LevelDirectorClass             (Parm, ZeroConstructor, IsPlainOldData)

void UChallengeLevelRules::SpawnLevelDirector(class UClass* LevelDirectorClass)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChallengeLevelRules.SpawnLevelDirector");

	UChallengeLevelRules_SpawnLevelDirector_Params params;
	params.LevelDirectorClass = LevelDirectorClass;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChallengeLevelRules.OnReceiveTriggerMsg
// (Native, Public)
// Parameters:
// class UTriggerAction*          TriggerAction                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Msg                            (Parm, ZeroConstructor)

void UChallengeLevelRules::OnReceiveTriggerMsg(class UTriggerAction* TriggerAction, const struct FString& Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChallengeLevelRules.OnReceiveTriggerMsg");

	UChallengeLevelRules_OnReceiveTriggerMsg_Params params;
	params.TriggerAction = TriggerAction;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChallengeLevelRules.InitLevel
// (Native, Public)

void UChallengeLevelRules::InitLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChallengeLevelRules.InitLevel");

	UChallengeLevelRules_InitLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetSkinMaterial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::SetSkinMaterial(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetSkinMaterial");

	UCharacterAvatarComponent_SetSkinMaterial_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetNormalMaterial
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FMeshPackage            meshPack                       (Parm, OutParm)
// class UMeshComponent*          meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::SetNormalMaterial(class UMeshComponent* meshComp, int slotID, struct FMeshPackage* meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetNormalMaterial");

	UCharacterAvatarComponent_SetNormalMaterial_Params params;
	params.meshComp = meshComp;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshPack != nullptr)
		*meshPack = params.meshPack;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetBodySuitsMaterial
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FMeshPackage            meshPack                       (Parm, OutParm)
// class UMeshComponent*          meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::SetBodySuitsMaterial(class UMeshComponent* meshComp, struct FMeshPackage* meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetBodySuitsMaterial");

	UCharacterAvatarComponent_SetBodySuitsMaterial_Params params;
	params.meshComp = meshComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshPack != nullptr)
		*meshPack = params.meshPack;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetAvatarVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAvatarSlotType                slotType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Visible                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsForCE                        (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::SetAvatarVisibility(EAvatarSlotType slotType, bool Visible, bool IsForCE)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetAvatarVisibility");

	UCharacterAvatarComponent_SetAvatarVisibility_Params params;
	params.slotType = slotType;
	params.Visible = Visible;
	params.IsForCE = IsForCE;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetAvatarGender
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            AGender                        (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::SetAvatarGender(int AGender)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetAvatarGender");

	UCharacterAvatarComponent_SetAvatarGender_Params params;
	params.AGender = AGender;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.SetAllMeshCollisionState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::SetAllMeshCollisionState(bool IsEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.SetAllMeshCollisionState");

	UCharacterAvatarComponent_SetAllMeshCollisionState_Params params;
	params.IsEnable = IsEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.RemoveSyncSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::RemoveSyncSlot(int Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.RemoveSyncSlot");

	UCharacterAvatarComponent_RemoveSyncSlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.RefreshAvatar
// (Final, Native, Public, BlueprintCallable)

void UCharacterAvatarComponent::RefreshAvatar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.RefreshAvatar");

	UCharacterAvatarComponent_RefreshAvatar_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.PutOnEquipmentByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           skMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             stMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::PutOnEquipmentByItemHandle(class UBattleItemHandleBase* ItemHandle, class USkeletalMesh* skMesh, class UStaticMesh* stMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.PutOnEquipmentByItemHandle");

	UCharacterAvatarComponent_PutOnEquipmentByItemHandle_Params params;
	params.ItemHandle = ItemHandle;
	params.skMesh = skMesh;
	params.stMesh = stMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_SetDefaultCfg
// (Final, Native, Public)

void UCharacterAvatarComponent::OnRep_SetDefaultCfg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_SetDefaultCfg");

	UCharacterAvatarComponent_OnRep_SetDefaultCfg_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_EquipParachute
// (Final, Native, Public)

void UCharacterAvatarComponent::OnRep_EquipParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_EquipParachute");

	UCharacterAvatarComponent_OnRep_EquipParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_AvatarMeshChanged
// (Final, Native, Public)

void UCharacterAvatarComponent::OnRep_AvatarMeshChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnRep_AvatarMeshChanged");

	UCharacterAvatarComponent_OnRep_AvatarMeshChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnMeshLoaded
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FSoftObjectPath         AssetList                      (Parm)
// class UBattleItemHandleBase*   itemHandles                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isReplaced                     (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::OnMeshLoaded(const struct FSoftObjectPath& AssetList, class UBattleItemHandleBase* itemHandles, bool isReplaced)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnMeshLoaded");

	UCharacterAvatarComponent_OnMeshLoaded_Params params;
	params.AssetList = AssetList;
	params.itemHandles = itemHandles;
	params.isReplaced = isReplaced;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnItemHandleLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::OnItemHandleLoaded(const struct FItemDefineID& DefineID, class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnItemHandleLoaded");

	UCharacterAvatarComponent_OnItemHandleLoaded_Params params;
	params.DefineID = DefineID;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.OnDefaultItemLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::OnDefaultItemLoaded(const struct FItemDefineID& DefineID, class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.OnDefaultItemLoaded");

	UCharacterAvatarComponent_OnDefaultItemLoaded_Params params;
	params.DefineID = DefineID;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.NetSyncDefData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::NetSyncDefData(int Slot, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.NetSyncDefData");

	UCharacterAvatarComponent_NetSyncDefData_Params params;
	params.Slot = Slot;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.NetSyncData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// ESyncOperation                 Type                           (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::NetSyncData(int Slot, ESyncOperation Type, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.NetSyncData");

	UCharacterAvatarComponent_NetSyncData_Params params;
	params.Slot = Slot;
	params.Type = Type;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.NetApplyHeadMesh
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::NetApplyHeadMesh(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.NetApplyHeadMesh");

	UCharacterAvatarComponent_NetApplyHeadMesh_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.LoadMeshsAsync
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   handleList                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           needDirectLoad                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::LoadMeshsAsync(class UBattleItemHandleBase* handleList, bool needDirectLoad)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.LoadMeshsAsync");

	UCharacterAvatarComponent_LoadMeshsAsync_Params params;
	params.handleList = handleList;
	params.needDirectLoad = needDirectLoad;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.IsTeammate
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::IsTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.IsTeammate");

	UCharacterAvatarComponent_IsTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.IsSlotVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::IsSlotVisible(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.IsSlotVisible");

	UCharacterAvatarComponent_IsSlotVisible_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.IsNeedReplaced
// (Native, Protected, BlueprintCallable)
// Parameters:
// class UBackpackAvatarHandle*   doReplaceHandle                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::IsNeedReplaced(class UBackpackAvatarHandle* doReplaceHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.IsNeedReplaced");

	UCharacterAvatarComponent_IsNeedReplaced_Params params;
	params.doReplaceHandle = doReplaceHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitMasterComponent
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            AGender                        (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::InitMasterComponent(int AGender)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitMasterComponent");

	UCharacterAvatarComponent_InitMasterComponent_Params params;
	params.AGender = AGender;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitialAvatarParam
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            AGender                        (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::InitialAvatarParam(int AGender)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitialAvatarParam");

	UCharacterAvatarComponent_InitialAvatarParam_Params params;
	params.AGender = AGender;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultMesh
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::InitDefaultMesh(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultMesh");

	UCharacterAvatarComponent_InitDefaultMesh_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultAvatarByResID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            avatarGender                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            Head                           (Parm, ZeroConstructor, IsPlainOldData)
// int                            hair                           (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::InitDefaultAvatarByResID(int avatarGender, int Head, int hair)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultAvatarByResID");

	UCharacterAvatarComponent_InitDefaultAvatarByResID_Params params;
	params.avatarGender = avatarGender;
	params.Head = Head;
	params.hair = hair;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultAvatar
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::InitDefaultAvatar(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitDefaultAvatar");

	UCharacterAvatarComponent_InitDefaultAvatar_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.InitBodyMeshByHead
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int                            Head                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::InitBodyMeshByHead(int Head)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.InitBodyMeshByHead");

	UCharacterAvatarComponent_InitBodyMeshByHead_Params params;
	params.Head = Head;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.GetReplacedMeshResRef
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UBackpackAvatarHandle*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FSoftObjectPath         AssetRef                       (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::GetReplacedMeshResRef(class UBackpackAvatarHandle* Handle, struct FSoftObjectPath* AssetRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.GetReplacedMeshResRef");

	UCharacterAvatarComponent_GetReplacedMeshResRef_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (AssetRef != nullptr)
		*AssetRef = params.AssetRef;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.GetMeshResRef
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UBackpackAvatarHandle*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FSoftObjectPath         AssetRef                       (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::GetMeshResRef(class UBackpackAvatarHandle* Handle, struct FSoftObjectPath* AssetRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.GetMeshResRef");

	UCharacterAvatarComponent_GetMeshResRef_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (AssetRef != nullptr)
		*AssetRef = params.AssetRef;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.GetLoadedHandle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackAvatarHandle*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBackpackAvatarHandle* UCharacterAvatarComponent::GetLoadedHandle(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.GetLoadedHandle");

	UCharacterAvatarComponent_GetLoadedHandle_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.GetDefaultBodyItemIDList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<int>                    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<int> UCharacterAvatarComponent::GetDefaultBodyItemIDList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.GetDefaultBodyItemIDList");

	UCharacterAvatarComponent_GetDefaultBodyItemIDList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.GetDefaultBodyHandles
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UBackpackAvatarHandle*   HeadHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UBackpackAvatarHandle*> BodyHandleList                 (Parm, OutParm, ZeroConstructor)

void UCharacterAvatarComponent::GetDefaultBodyHandles(class UBackpackAvatarHandle* HeadHandle, TArray<class UBackpackAvatarHandle*>* BodyHandleList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.GetDefaultBodyHandles");

	UCharacterAvatarComponent_GetDefaultBodyHandles_Params params;
	params.HeadHandle = HeadHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (BodyHandleList != nullptr)
		*BodyHandleList = params.BodyHandleList;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ClearMeshBySlot
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           putDefault                     (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::ClearMeshBySlot(int Slot, bool putDefault)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ClearMeshBySlot");

	UCharacterAvatarComponent_ClearMeshBySlot_Params params;
	params.Slot = Slot;
	params.putDefault = putDefault;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.CheckSlotInfo
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isHide                         (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           isReplace                      (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           visable                        (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           deineID                        (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::CheckSlotInfo(int slotID, bool* isHide, bool* isReplace, bool* visable, struct FItemDefineID* deineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.CheckSlotInfo");

	UCharacterAvatarComponent_CheckSlotInfo_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (isHide != nullptr)
		*isHide = params.isHide;
	if (isReplace != nullptr)
		*isReplace = params.isReplace;
	if (visable != nullptr)
		*visable = params.visable;
	if (deineID != nullptr)
		*deineID = params.deineID;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.CheckShouldEquipDefaultItem
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::CheckShouldEquipDefaultItem(int Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.CheckShouldEquipDefaultItem");

	UCharacterAvatarComponent_CheckShouldEquipDefaultItem_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.CheckIsHiddenByOther
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            itemResID                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::CheckIsHiddenByOther(int itemResID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.CheckIsHiddenByOther");

	UCharacterAvatarComponent_CheckIsHiddenByOther_Params params;
	params.itemResID = itemResID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.CheckIsDefaultAvatar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           definedID                      (Parm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::CheckIsDefaultAvatar(const struct FItemDefineID& definedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.CheckIsDefaultAvatar");

	UCharacterAvatarComponent_CheckIsDefaultAvatar_Params params;
	params.definedID = definedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.CheckAlreadyEquipped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::CheckAlreadyEquipped(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.CheckAlreadyEquipped");

	UCharacterAvatarComponent_CheckAlreadyEquipped_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyStaticMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             pSM                            (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::ApplyStaticMeshByID(int Slot, class UStaticMesh* pSM, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyStaticMeshByID");

	UCharacterAvatarComponent_ApplyStaticMeshByID_Params params;
	params.Slot = Slot;
	params.pSM = pSM;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ApplySkeletalMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           Mesh                           (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterAvatarComponent::ApplySkeletalMeshByID(int Slot, class USkeletalMesh* Mesh, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ApplySkeletalMeshByID");

	UCharacterAvatarComponent_ApplySkeletalMeshByID_Params params;
	params.Slot = Slot;
	params.Mesh = Mesh;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyMeshCompCollision
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterAvatarComponent::ApplyMeshCompCollision(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyMeshCompCollision");

	UCharacterAvatarComponent_ApplyMeshCompCollision_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyMaterial
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UCharacterAvatarComponent::ApplyMaterial(class UBattleItemHandleBase* ItemHandle, class UMeshComponent* meshComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyMaterial");

	UCharacterAvatarComponent_ApplyMaterial_Params params;
	params.ItemHandle = ItemHandle;
	params.meshComp = meshComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyAnimation
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FMeshPackage            meshPack                       (Parm, OutParm)

void UCharacterAvatarComponent::ApplyAnimation(int Slot, struct FMeshPackage* meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterAvatarComponent.ApplyAnimation");

	UCharacterAvatarComponent_ApplyAnimation_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshPack != nullptr)
		*meshPack = params.meshPack;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.VerifyClientTimeStamp
// (Final, Native, Public)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCharacterParachuteComponent::VerifyClientTimeStamp(float TimeStamp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.VerifyClientTimeStamp");

	UCharacterParachuteComponent_VerifyClientTimeStamp_Params params;
	params.TimeStamp = TimeStamp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateRotation
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ThrottleInput                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          SteerInput                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EParachuteState>   State                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                ControlRotation                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UCharacterParachuteComponent::UpdateRotation(float DeltaTime, float ThrottleInput, float SteerInput, TEnumAsByte<EParachuteState> State, const struct FRotator& ControlRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateRotation");

	UCharacterParachuteComponent_UpdateRotation_Params params;
	params.DeltaTime = DeltaTime;
	params.ThrottleInput = ThrottleInput;
	params.SteerInput = SteerInput;
	params.State = State;
	params.ControlRotation = ControlRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateParachuteState
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ThrottleInput                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          SteerInput                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EParachuteState>   State                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                ControlRotation                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UCharacterParachuteComponent::UpdateParachuteState(float DeltaTime, float ThrottleInput, float SteerInput, TEnumAsByte<EParachuteState> State, const struct FRotator& ControlRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateParachuteState");

	UCharacterParachuteComponent_UpdateParachuteState_Params params;
	params.DeltaTime = DeltaTime;
	params.ThrottleInput = ThrottleInput;
	params.SteerInput = SteerInput;
	params.State = State;
	params.ControlRotation = ControlRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateParachuteOpenedRotation
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          InputForward                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          InputRight                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterParachuteComponent::UpdateParachuteOpenedRotation(float InputForward, float InputRight, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateParachuteOpenedRotation");

	UCharacterParachuteComponent_UpdateParachuteOpenedRotation_Params params;
	params.InputForward = InputForward;
	params.InputRight = InputRight;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateFreeFallRotation
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                CameraWorldRotation            (Parm, IsPlainOldData)
// float                          InputForward                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          InputRight                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterParachuteComponent::UpdateFreeFallRotation(const struct FRotator& CameraWorldRotation, float InputForward, float InputRight, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.UpdateFreeFallRotation");

	UCharacterParachuteComponent_UpdateFreeFallRotation_Params params;
	params.CameraWorldRotation = CameraWorldRotation;
	params.InputForward = InputForward;
	params.InputRight = InputRight;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.TickParachuteComponent
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ThrottleInput                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          SteeringInput                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                ControlRotation                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UCharacterParachuteComponent::TickParachuteComponent(float DeltaTime, float ThrottleInput, float SteeringInput, const struct FRotator& ControlRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.TickParachuteComponent");

	UCharacterParachuteComponent_TickParachuteComponent_Params params;
	params.DeltaTime = DeltaTime;
	params.ThrottleInput = ThrottleInput;
	params.SteeringInput = SteeringInput;
	params.ControlRotation = ControlRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.StopParachute
// (Final, Native, Public, BlueprintCallable)

void UCharacterParachuteComponent::StopParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.StopParachute");

	UCharacterParachuteComponent_StopParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.StartParachute
// (Final, Native, Public, BlueprintCallable)

void UCharacterParachuteComponent::StartParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.StartParachute");

	UCharacterParachuteComponent_StartParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.ResetVelocity
// (Final, Native, Public, BlueprintCallable)

void UCharacterParachuteComponent::ResetVelocity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.ResetVelocity");

	UCharacterParachuteComponent_ResetVelocity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.PostNetReceiveNewState
// (Final, Native, Public)

void UCharacterParachuteComponent::PostNetReceiveNewState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.PostNetReceiveNewState");

	UCharacterParachuteComponent_PostNetReceiveNewState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.OnPreReconnectOnServer
// (Final, Native, Public)

void UCharacterParachuteComponent::OnPreReconnectOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.OnPreReconnectOnServer");

	UCharacterParachuteComponent_OnPreReconnectOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.InvalidateAdjustFollowerLocation
// (Final, Native, Public)

void UCharacterParachuteComponent::InvalidateAdjustFollowerLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.InvalidateAdjustFollowerLocation");

	UCharacterParachuteComponent_InvalidateAdjustFollowerLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.GetReplicatedRightInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UCharacterParachuteComponent::GetReplicatedRightInput()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.GetReplicatedRightInput");

	UCharacterParachuteComponent_GetReplicatedRightInput_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.GetReplicatedForwardInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UCharacterParachuteComponent::GetReplicatedForwardInput()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.GetReplicatedForwardInput");

	UCharacterParachuteComponent_GetReplicatedForwardInput_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.CalParachuteOpenedVelocity
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// float                          InputForward                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          InputRight                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector UCharacterParachuteComponent::CalParachuteOpenedVelocity(float InputForward, float InputRight, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.CalParachuteOpenedVelocity");

	UCharacterParachuteComponent_CalParachuteOpenedVelocity_Params params;
	params.InputForward = InputForward;
	params.InputRight = InputRight;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.CalFreeFallVelocity
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// float                          InputForward                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          InputRight                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector UCharacterParachuteComponent::CalFreeFallVelocity(float InputForward, float InputRight, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.CalFreeFallVelocity");

	UCharacterParachuteComponent_CalFreeFallVelocity_Params params;
	params.InputForward = InputForward;
	params.InputRight = InputRight;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.AngleInterpTo
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          Current                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          Target                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          Speed                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UCharacterParachuteComponent::AngleInterpTo(float Current, float Target, float DeltaTime, float Speed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.AngleInterpTo");

	UCharacterParachuteComponent_AngleInterpTo_Params params;
	params.Current = Current;
	params.Target = Target;
	params.DeltaTime = DeltaTime;
	params.Speed = Speed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CharacterParachuteComponent.AdjustFollowerLocation
// (Final, Native, Public)

void UCharacterParachuteComponent::AdjustFollowerLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterParachuteComponent.AdjustFollowerLocation");

	UCharacterParachuteComponent_AdjustFollowerLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.UpdateOwnerClientCreateWeapon
// (Final, Native, Protected)

void UWeaponManagerComponent::UpdateOwnerClientCreateWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.UpdateOwnerClientCreateWeapon");

	UWeaponManagerComponent_UpdateOwnerClientCreateWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.SwitchWeaponBySlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::SwitchWeaponBySlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bUseAnimation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.SwitchWeaponBySlot");

	UWeaponManagerComponent_SwitchWeaponBySlot_Params params;
	params.Slot = Slot;
	params.bUseAnimation = bUseAnimation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.SwitchWeaponByLogicSocket_IdleToBackpackFinished
// (Final, Native, Protected)

void UWeaponManagerComponent::SwitchWeaponByLogicSocket_IdleToBackpackFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.SwitchWeaponByLogicSocket_IdleToBackpackFinished");

	UWeaponManagerComponent_SwitchWeaponByLogicSocket_IdleToBackpackFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.SwapWeaponByPropSlotFinishedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot1                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot2                          (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::SwapWeaponByPropSlotFinishedDelegate__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> Slot1, TEnumAsByte<ESurviveWeaponPropSlot> Slot2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.SwapWeaponByPropSlotFinishedDelegate__DelegateSignature");

	UWeaponManagerComponent_SwapWeaponByPropSlotFinishedDelegate__DelegateSignature_Params params;
	params.Slot1 = Slot1;
	params.Slot2 = Slot2;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.SimulatedWeaponChangedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponManagerComponent::SimulatedWeaponChangedDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.SimulatedWeaponChangedDelegate__DelegateSignature");

	UWeaponManagerComponent_SimulatedWeaponChangedDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.RefreshWeaponLogicSocketInSpawnDataCacheByPropSlotOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::RefreshWeaponLogicSocketInSpawnDataCacheByPropSlotOnServer(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.RefreshWeaponLogicSocketInSpawnDataCacheByPropSlotOnServer");

	UWeaponManagerComponent_RefreshWeaponLogicSocketInSpawnDataCacheByPropSlotOnServer_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateMeleeSlot
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_WeaponSystemDataOnSimulateMeleeSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateMeleeSlot");

	UWeaponManagerComponent_OnRep_WeaponSystemDataOnSimulateMeleeSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateHandPropSlot
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_WeaponSystemDataOnSimulateHandPropSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateHandPropSlot");

	UWeaponManagerComponent_OnRep_WeaponSystemDataOnSimulateHandPropSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSubSlot
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_WeaponSystemDataOnSimulateClientSubSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSubSlot");

	UWeaponManagerComponent_OnRep_WeaponSystemDataOnSimulateClientSubSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSlot2
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_WeaponSystemDataOnSimulateClientSlot2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSlot2");

	UWeaponManagerComponent_OnRep_WeaponSystemDataOnSimulateClientSlot2_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSlot1
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_WeaponSystemDataOnSimulateClientSlot1()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_WeaponSystemDataOnSimulateClientSlot1");

	UWeaponManagerComponent_OnRep_WeaponSystemDataOnSimulateClientSlot1_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentWeaponReplicated
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_CurrentWeaponReplicated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentWeaponReplicated");

	UWeaponManagerComponent_OnRep_CurrentWeaponReplicated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentWeaponLogicSocket
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_CurrentWeaponLogicSocket()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentWeaponLogicSocket");

	UWeaponManagerComponent_OnRep_CurrentWeaponLogicSocket_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentShieldWeaponReplicated
// (Final, Native, Protected)

void UWeaponManagerComponent::OnRep_CurrentShieldWeaponReplicated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnRep_CurrentShieldWeaponReplicated");

	UWeaponManagerComponent_OnRep_CurrentShieldWeaponReplicated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnReconnectOnServer
// (Native, Protected, BlueprintCallable)

void UWeaponManagerComponent::OnReconnectOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnReconnectOnServer");

	UWeaponManagerComponent_OnReconnectOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.OnReconnectOnClient
// (Native, Protected)

void UWeaponManagerComponent::OnReconnectOnClient()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.OnReconnectOnClient");

	UWeaponManagerComponent_OnReconnectOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.LogInventoryDataInfo
// (Final, Native, Public, BlueprintCallable)

void UWeaponManagerComponent::LogInventoryDataInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.LogInventoryDataInfo");

	UWeaponManagerComponent_LogInventoryDataInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.LocalSwapWeaponByPropSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot1                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot2                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForce                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponManagerComponent::LocalSwapWeaponByPropSlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot1, TEnumAsByte<ESurviveWeaponPropSlot> Slot2, bool bForce)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.LocalSwapWeaponByPropSlot");

	UWeaponManagerComponent_LocalSwapWeaponByPropSlot_Params params;
	params.Slot1 = Slot1;
	params.Slot2 = Slot2;
	params.bForce = bForce;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.LocalForceFinishSwitchWeapon
// (Final, Native, Public, BlueprintCallable)

void UWeaponManagerComponent::LocalForceFinishSwitchWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.LocalForceFinishSwitchWeapon");

	UWeaponManagerComponent_LocalForceFinishSwitchWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.LocalEquipWeaponFromBackpackFinishedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponManagerComponent::LocalEquipWeaponFromBackpackFinishedDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.LocalEquipWeaponFromBackpackFinishedDelegate__DelegateSignature");

	UWeaponManagerComponent_LocalEquipWeaponFromBackpackFinishedDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.LocalEquipWeaponFromBackpackFinishedCallback
// (Final, Native, Protected)

void UWeaponManagerComponent::LocalEquipWeaponFromBackpackFinishedCallback()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.LocalEquipWeaponFromBackpackFinishedCallback");

	UWeaponManagerComponent_LocalEquipWeaponFromBackpackFinishedCallback_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.LocalBackpackCurerrentWeaponFinishedCallback
// (Final, Native, Protected)

void UWeaponManagerComponent::LocalBackpackCurerrentWeaponFinishedCallback()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.LocalBackpackCurerrentWeaponFinishedCallback");

	UWeaponManagerComponent_LocalBackpackCurerrentWeaponFinishedCallback_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.LocalBackpackCurerrentWeaponFinishDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponManagerComponent::LocalBackpackCurerrentWeaponFinishDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.LocalBackpackCurerrentWeaponFinishDelegate__DelegateSignature");

	UWeaponManagerComponent_LocalBackpackCurerrentWeaponFinishDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.IsWeaponSpawnDataCacheIsEmpty
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponManagerComponent::IsWeaponSpawnDataCacheIsEmpty()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.IsWeaponSpawnDataCacheIsEmpty");

	UWeaponManagerComponent_IsWeaponSpawnDataCacheIsEmpty_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.IsRecoveringWeaponOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponManagerComponent::IsRecoveringWeaponOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.IsRecoveringWeaponOnServer");

	UWeaponManagerComponent_IsRecoveringWeaponOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.IsCreatingWeaponOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponManagerComponent::IsCreatingWeaponOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.IsCreatingWeaponOnServer");

	UWeaponManagerComponent_IsCreatingWeaponOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetShieldWeaponSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponManagerComponent::GetShieldWeaponSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetShieldWeaponSlot");

	UWeaponManagerComponent_GetShieldWeaponSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetShieldWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* UWeaponManagerComponent::GetShieldWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetShieldWeapon");

	UWeaponManagerComponent_GetShieldWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetPropSlotByLogicSocket
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   LogicSocket                    (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESurviveWeaponPropSlot> UWeaponManagerComponent::GetPropSlotByLogicSocket(const struct FName& LogicSocket)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetPropSlotByLogicSocket");

	UWeaponManagerComponent_GetPropSlotByLogicSocket_Params params;
	params.LogicSocket = LogicSocket;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetLogicSocketBySlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponManagerComponent::GetLogicSocketBySlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetLogicSocketBySlot");

	UWeaponManagerComponent_GetLogicSocketBySlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByPropSlotOnServerOrAutonomousClient
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* UWeaponManagerComponent::GetInventoryWeaponByPropSlotOnServerOrAutonomousClient(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByPropSlotOnServerOrAutonomousClient");

	UWeaponManagerComponent_GetInventoryWeaponByPropSlotOnServerOrAutonomousClient_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByPropSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* UWeaponManagerComponent::GetInventoryWeaponByPropSlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByPropSlot");

	UWeaponManagerComponent_GetInventoryWeaponByPropSlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByLogicSocket
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   LogicSocket                    (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* UWeaponManagerComponent::GetInventoryWeaponByLogicSocket(const struct FName& LogicSocket)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetInventoryWeaponByLogicSocket");

	UWeaponManagerComponent_GetInventoryWeaponByLogicSocket_Params params;
	params.LogicSocket = LogicSocket;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetGrenadeSpecificSlotNameByWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponManagerComponent::GetGrenadeSpecificSlotNameByWeapon(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetGrenadeSpecificSlotNameByWeapon");

	UWeaponManagerComponent_GetGrenadeSpecificSlotNameByWeapon_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetGrenadeDefindIDBySlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   LogicSlot                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID UWeaponManagerComponent::GetGrenadeDefindIDBySlot(const struct FName& LogicSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetGrenadeDefindIDBySlot");

	UWeaponManagerComponent_GetGrenadeDefindIDBySlot_Params params;
	params.LogicSlot = LogicSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* UWeaponManagerComponent::GetCurrentUsingWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingWeapon");

	UWeaponManagerComponent_GetCurrentUsingWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingPropSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESurviveWeaponPropSlot> UWeaponManagerComponent::GetCurrentUsingPropSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingPropSlot");

	UWeaponManagerComponent_GetCurrentUsingPropSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingLogicSocketOnServer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponManagerComponent::GetCurrentUsingLogicSocketOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingLogicSocketOnServer");

	UWeaponManagerComponent_GetCurrentUsingLogicSocketOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingLogicSocket
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponManagerComponent::GetCurrentUsingLogicSocket()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetCurrentUsingLogicSocket");

	UWeaponManagerComponent_GetCurrentUsingLogicSocket_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetBagLevelBySpesificID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UWeaponManagerComponent::GetBagLevelBySpesificID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetBagLevelBySpesificID");

	UWeaponManagerComponent_GetBagLevelBySpesificID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetBagLevel
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UWeaponManagerComponent::GetBagLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetBagLevel");

	UWeaponManagerComponent_GetBagLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.GetAllInventoryWeaponList
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           bForceUseMapData               (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class ASTExtraWeapon*>  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class ASTExtraWeapon*> UWeaponManagerComponent::GetAllInventoryWeaponList(bool bForceUseMapData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.GetAllInventoryWeaponList");

	UWeaponManagerComponent_GetAllInventoryWeaponList_Params params;
	params.bForceUseMapData = bForceUseMapData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.ForceBroadcastChangeAllInventoryDataEvent
// (Final, Native, Public, BlueprintCallable)

void UWeaponManagerComponent::ForceBroadcastChangeAllInventoryDataEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.ForceBroadcastChangeAllInventoryDataEvent");

	UWeaponManagerComponent_ForceBroadcastChangeAllInventoryDataEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.EnableAllBroadcast
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::EnableAllBroadcast(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.EnableAllBroadcast");

	UWeaponManagerComponent_EnableAllBroadcast_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.DropWeapon
// (Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// EBattleItemDropReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::DropWeapon(class ASTExtraWeapon* Weapon, EBattleItemDropReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.DropWeapon");

	UWeaponManagerComponent_DropWeapon_Params params;
	params.Weapon = Weapon;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.DeleteGrenadeSlotAndDefindID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   LogicSlot                      (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::DeleteGrenadeSlotAndDefindID(const struct FName& LogicSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.DeleteGrenadeSlotAndDefindID");

	UWeaponManagerComponent_DeleteGrenadeSlotAndDefindID_Params params;
	params.LogicSlot = LogicSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.DebugReconnectToClientOnServer
// (Final, Native, Public, BlueprintCallable)

void UWeaponManagerComponent::DebugReconnectToClientOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.DebugReconnectToClientOnServer");

	UWeaponManagerComponent_DebugReconnectToClientOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.DebugDisconnetToServerOnClient
// (Final, Native, Public, BlueprintCallable)

void UWeaponManagerComponent::DebugDisconnetToServerOnClient()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.DebugDisconnetToServerOnClient");

	UWeaponManagerComponent_DebugDisconnetToServerOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.ChangeInventoryDataDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot               (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::ChangeInventoryDataDelegate__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.ChangeInventoryDataDelegate__DelegateSignature");

	UWeaponManagerComponent_ChangeInventoryDataDelegate__DelegateSignature_Params params;
	params.TargetChangeSlot = TargetChangeSlot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.ChangeCurrentUsingWeaponDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot               (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponManagerComponent::ChangeCurrentUsingWeaponDelegate__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponManagerComponent.ChangeCurrentUsingWeaponDelegate__DelegateSignature");

	UWeaponManagerComponent_ChangeCurrentUsingWeaponDelegate__DelegateSignature_Params params;
	params.TargetChangeSlot = TargetChangeSlot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponManagerComponent.AddOrSetGrenadeSlotAndDefindID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   LogicSlot                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ID                             (Parm)

void UWeaponManagerComponent::AddOrSetGrenadeSlotAndDefindID(const struct FName& LogicSlot, const struct FItemDefineID& ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponManagerComponent.AddOrSetGrenadeSlotAndDefindID");

	UWeaponManagerComponent_AddOrSetGrenadeSlotAndDefindID_Params params;
	params.LogicSlot = LogicSlot;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.UpdateDataWhenBagChangedOnServer
// (Final, Native, Protected)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// EBattleItemOperationType       operationType                  (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void UCharacterWeaponManagerComponent::UpdateDataWhenBagChangedOnServer(const struct FItemDefineID& DefineID, EBattleItemOperationType operationType, unsigned char Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.UpdateDataWhenBagChangedOnServer");

	UCharacterWeaponManagerComponent_UpdateDataWhenBagChangedOnServer_Params params;
	params.DefineID = DefineID;
	params.operationType = operationType;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.UpdateDataWhenBagChangedOnAutonomous
// (Final, Native, Protected)

void UCharacterWeaponManagerComponent::UpdateDataWhenBagChangedOnAutonomous()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.UpdateDataWhenBagChangedOnAutonomous");

	UCharacterWeaponManagerComponent_UpdateDataWhenBagChangedOnAutonomous_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnRecoverOnServer
// (Native, Protected)

void UCharacterWeaponManagerComponent::OnRecoverOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnRecoverOnServer");

	UCharacterWeaponManagerComponent_OnRecoverOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnReconnectOnServer
// (Native, Protected)

void UCharacterWeaponManagerComponent::OnReconnectOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnReconnectOnServer");

	UCharacterWeaponManagerComponent_OnReconnectOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnReconnectOnClient
// (Native, Protected)

void UCharacterWeaponManagerComponent::OnReconnectOnClient()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnReconnectOnClient");

	UCharacterWeaponManagerComponent_OnReconnectOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnDisconnectToClientOnServer
// (Final, Native, Protected)

void UCharacterWeaponManagerComponent::OnDisconnectToClientOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.OnDisconnectToClientOnServer");

	UCharacterWeaponManagerComponent_OnDisconnectToClientOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CharacterWeaponManagerComponent.GetBagLevel
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UCharacterWeaponManagerComponent::GetBagLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CharacterWeaponManagerComponent.GetBagLevel");

	UCharacterWeaponManagerComponent_GetBagLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.YearBeastCountDown
// (Final, Native, Public, BlueprintCallable)

void UChasingBar::YearBeastCountDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.YearBeastCountDown");

	UChasingBar_YearBeastCountDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.UpdateCountDownText
// (Event, Public, BlueprintEvent)

void UChasingBar::UpdateCountDownText()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.UpdateCountDownText");

	UChasingBar_UpdateCountDownText_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.OnPlayerEnterExitBlueCircle
// (Event, Public, BlueprintEvent)

void UChasingBar::OnPlayerEnterExitBlueCircle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.OnPlayerEnterExitBlueCircle");

	UChasingBar_OnPlayerEnterExitBlueCircle_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.OnCountDownTextInvisible
// (Event, Public, BlueprintEvent)

void UChasingBar::OnCountDownTextInvisible()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.OnCountDownTextInvisible");

	UChasingBar_OnCountDownTextInvisible_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.IsPlayerOutBlueCircle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   CurPawn                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UChasingBar::IsPlayerOutBlueCircle(class APawn* CurPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.IsPlayerOutBlueCircle");

	UChasingBar_IsPlayerOutBlueCircle_Params params;
	params.CurPawn = CurPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.IsPlayerInWhiteCircle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   CurPawn                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UChasingBar::IsPlayerInWhiteCircle(class APawn* CurPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.IsPlayerInWhiteCircle");

	UChasingBar_IsPlayerInWhiteCircle_Params params;
	params.CurPawn = CurPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.IsBlueCircleMoving
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UChasingBar::IsBlueCircleMoving()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.IsBlueCircleMoving");

	UChasingBar_IsBlueCircleMoving_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.IsBlueCircleAppearAndCountDown
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UChasingBar::IsBlueCircleAppearAndCountDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.IsBlueCircleAppearAndCountDown");

	UChasingBar_IsBlueCircleAppearAndCountDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.ClearProgressBar
// (Event, Public, BlueprintEvent)

void UChasingBar::ClearProgressBar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.ClearProgressBar");

	UChasingBar_ClearProgressBar_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.CleanTheProgressBar
// (Event, Public, BlueprintEvent)

void UChasingBar::CleanTheProgressBar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.CleanTheProgressBar");

	UChasingBar_CleanTheProgressBar_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.CheckToCleanProgress
// (Final, Native, Public, BlueprintCallable)

void UChasingBar::CheckToCleanProgress()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.CheckToCleanProgress");

	UChasingBar_CheckToCleanProgress_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChasingBar.CalPlayerEscapePercent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UChasingBar::CalPlayerEscapePercent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.CalPlayerEscapePercent");

	UChasingBar_CalPlayerEscapePercent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ChasingBar.BlueCirclePreMoveCountDown
// (Final, Native, Public, BlueprintCallable)

void UChasingBar::BlueCirclePreMoveCountDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChasingBar.BlueCirclePreMoveCountDown");

	UChasingBar_BlueCirclePreMoveCountDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.UpdateQuickItemText
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            msgID                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            alternateMsgID                 (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::UpdateQuickItemText(int msgID, int resID, int alternateMsgID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.UpdateQuickItemText");

	UChatComponent_UpdateQuickItemText_Params params;
	params.msgID = msgID;
	params.resID = resID;
	params.alternateMsgID = alternateMsgID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.ShowQuickPanel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::ShowQuickPanel(bool bShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.ShowQuickPanel");

	UChatComponent_ShowQuickPanel_Params params;
	params.bShow = bShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.ShowFlag
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FInGameChatMsg          msgItem                        (ConstParm, Parm, OutParm, ReferenceParm)
// EChatFlagType                  flatType                       (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::ShowFlag(const struct FInGameChatMsg& msgItem, EChatFlagType flatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.ShowFlag");

	UChatComponent_ShowFlag_Params params;
	params.msgItem = msgItem;
	params.flatType = flatType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.ServerSendMsg
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FInGameChatMsg          msgItem                        (ConstParm, Parm, ReferenceParm)

void UChatComponent::ServerSendMsg(const struct FInGameChatMsg& msgItem)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.ServerSendMsg");

	UChatComponent_ServerSendMsg_Params params;
	params.msgItem = msgItem;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.SendDirtyFilterContent
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 content                        (Parm, ZeroConstructor)

void UChatComponent::SendDirtyFilterContent(const struct FString& content)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.SendDirtyFilterContent");

	UChatComponent_SendDirtyFilterContent_Params params;
	params.content = content;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.SendDirtyFilter
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 Name                           (Parm, ZeroConstructor)
// struct FString                 content                        (Parm, ZeroConstructor)
// bool                           isMe                           (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::SendDirtyFilter(const struct FString& Name, const struct FString& content, bool isMe)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.SendDirtyFilter");

	UChatComponent_SendDirtyFilter_Params params;
	params.Name = Name;
	params.content = content;
	params.isMe = isMe;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.OnInviteNextBattle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 gid                            (Parm, ZeroConstructor)
// struct FString                 Name                           (Parm, ZeroConstructor)

void UChatComponent::OnInviteNextBattle(const struct FString& gid, const struct FString& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.OnInviteNextBattle");

	UChatComponent_OnInviteNextBattle_Params params;
	params.gid = gid;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.OnFilterFinish
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 filterText                     (Parm, ZeroConstructor)

void UChatComponent::OnFilterFinish(const struct FString& filterText)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.OnFilterFinish");

	UChatComponent_OnFilterFinish_Params params;
	params.filterText = filterText;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.NotifyFriendReplyInvite
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FString                 str_gid                        (Parm, ZeroConstructor)
// struct FString                 sender_name                    (Parm, ZeroConstructor)
// bool                           bReply                         (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::NotifyFriendReplyInvite(const struct FString& str_gid, const struct FString& sender_name, bool bReply)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.NotifyFriendReplyInvite");

	UChatComponent_NotifyFriendReplyInvite_Params params;
	params.str_gid = str_gid;
	params.sender_name = sender_name;
	params.bReply = bReply;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.NotifyFriendInvite
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FString                 str_gid                        (Parm, ZeroConstructor)
// struct FString                 sender_name                    (Parm, ZeroConstructor)

void UChatComponent::NotifyFriendInvite(const struct FString& str_gid, const struct FString& sender_name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.NotifyFriendInvite");

	UChatComponent_NotifyFriendInvite_Params params;
	params.str_gid = str_gid;
	params.sender_name = sender_name;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.NotifyFriendChat
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 str_gid                        (Parm, ZeroConstructor)
// struct FString                 sender_name                    (Parm, ZeroConstructor)
// struct FString                 chat_content                   (Parm, ZeroConstructor)
// bool                           self_msg                       (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::NotifyFriendChat(const struct FString& str_gid, const struct FString& sender_name, const struct FString& chat_content, bool self_msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.NotifyFriendChat");

	UChatComponent_NotifyFriendChat_Params params;
	params.str_gid = str_gid;
	params.sender_name = sender_name;
	params.chat_content = chat_content;
	params.self_msg = self_msg;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.InviteNextBattleReply
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 gid                            (Parm, ZeroConstructor)
// struct FString                 Name                           (Parm, ZeroConstructor)
// bool                           bReply                         (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::InviteNextBattleReply(const struct FString& gid, const struct FString& Name, bool bReply)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.InviteNextBattleReply");

	UChatComponent_InviteNextBattleReply_Params params;
	params.gid = gid;
	params.Name = Name;
	params.bReply = bReply;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.FindTextIDByAudioID
// (Event, Public, BlueprintEvent)

void UChatComponent::FindTextIDByAudioID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.FindTextIDByAudioID");

	UChatComponent_FindTextIDByAudioID_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.CloseChatHistoryList
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UChatComponent::CloseChatHistoryList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.CloseChatHistoryList");

	UChatComponent_CloseChatHistoryList_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.ClientReceiveMsg
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FInGameChatMsg          msgItem                        (ConstParm, Parm, ReferenceParm)
// bool                           isMe                           (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::ClientReceiveMsg(const struct FInGameChatMsg& msgItem, bool isMe)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.ClientReceiveMsg");

	UChatComponent_ClientReceiveMsg_Params params;
	params.msgItem = msgItem;
	params.isMe = isMe;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.AddOneMsgToUI1
// (Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// struct FInGameChatMsg          Item                           (ConstParm, Parm, OutParm, ReferenceParm)
// struct FString                 Name                           (Parm, ZeroConstructor)
// struct FString                 content                        (Parm, ZeroConstructor)
// int                            msgID                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            audioID                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isMe                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           PlaySound                      (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::AddOneMsgToUI1(const struct FInGameChatMsg& Item, const struct FString& Name, const struct FString& content, int msgID, int audioID, bool isMe, bool PlaySound)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.AddOneMsgToUI1");

	UChatComponent_AddOneMsgToUI1_Params params;
	params.Item = Item;
	params.Name = Name;
	params.content = content;
	params.msgID = msgID;
	params.audioID = audioID;
	params.isMe = isMe;
	params.PlaySound = PlaySound;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ChatComponent.AddFriendChat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 gid                            (Parm, ZeroConstructor)
// struct FString                 Name                           (Parm, ZeroConstructor)
// struct FString                 content                        (Parm, ZeroConstructor)
// bool                           isSelf                         (Parm, ZeroConstructor, IsPlainOldData)

void UChatComponent::AddFriendChat(const struct FString& gid, const struct FString& Name, const struct FString& content, bool isSelf)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ChatComponent.AddFriendChat");

	UChatComponent_AddFriendChat_Params params;
	params.gid = gid;
	params.Name = Name;
	params.content = content;
	params.isSelf = isSelf;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CircleMgrComponent.SetGMCicleTime
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// float                          CDTime                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          LastTime                       (Parm, ZeroConstructor, IsPlainOldData)

void UCircleMgrComponent::SetGMCicleTime(float CDTime, float LastTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CircleMgrComponent.SetGMCicleTime");

	UCircleMgrComponent_SetGMCicleTime_Params params;
	params.CDTime = CDTime;
	params.LastTime = LastTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CircleMgrComponent.RetriveCircleInfo
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FReConnectGameStateInfo CurInfo                        (Parm, OutParm)

void UCircleMgrComponent::RetriveCircleInfo(struct FReConnectGameStateInfo* CurInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CircleMgrComponent.RetriveCircleInfo");

	UCircleMgrComponent_RetriveCircleInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (CurInfo != nullptr)
		*CurInfo = params.CurInfo;
}


// Function ShadowTrackerExtra.CommonBtnComponent.SetAutoOpenDoorMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Mode                           (Parm, ZeroConstructor, IsPlainOldData)

void UCommonBtnComponent::SetAutoOpenDoorMode(int Mode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.SetAutoOpenDoorMode");

	UCommonBtnComponent_SetAutoOpenDoorMode_Params params;
	params.Mode = Mode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CommonBtnComponent.SetAutoOpenDoorEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void UCommonBtnComponent::SetAutoOpenDoorEnable(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.SetAutoOpenDoorEnable");

	UCommonBtnComponent_SetAutoOpenDoorEnable_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CommonBtnComponent.IsAimingExtraDoor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APUBGDoor*               actionDoor                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCommonBtnComponent::IsAimingExtraDoor(class APUBGDoor* actionDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.IsAimingExtraDoor");

	UCommonBtnComponent_IsAimingExtraDoor_Params params;
	params.actionDoor = actionDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CommonBtnComponent.GetPriorityDoor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APUBGDoor*               ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APUBGDoor* UCommonBtnComponent::GetPriorityDoor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.GetPriorityDoor");

	UCommonBtnComponent_GetPriorityDoor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CommonBtnComponent.DoorRequireRPC
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class APUBGDoor*               actionDoor                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAimingExtraDoor               (Parm, ZeroConstructor, IsPlainOldData)

void UCommonBtnComponent::DoorRequireRPC(class APUBGDoor* actionDoor, bool bAimingExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.DoorRequireRPC");

	UCommonBtnComponent_DoorRequireRPC_Params params;
	params.actionDoor = actionDoor;
	params.bAimingExtraDoor = bAimingExtraDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CommonBtnComponent.BP_SimulateUIClick
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bExtraDoor                     (Parm, ZeroConstructor, IsPlainOldData)

void UCommonBtnComponent::BP_SimulateUIClick(bool bExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.BP_SimulateUIClick");

	UCommonBtnComponent_BP_SimulateUIClick_Params params;
	params.bExtraDoor = bExtraDoor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CommonBtnComponent.BP_ShowDoorBtn
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bOpen                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            doorOpenMode                   (Parm, ZeroConstructor, IsPlainOldData)

void UCommonBtnComponent::BP_ShowDoorBtn(bool bShow, bool bOpen, int doorOpenMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CommonBtnComponent.BP_ShowDoorBtn");

	UCommonBtnComponent_BP_ShowDoorBtn_Params params;
	params.bShow = bShow;
	params.bOpen = bOpen;
	params.doorOpenMode = doorOpenMode;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameReplay.StopRecordingReplay
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::StopRecordingReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.StopRecordingReplay");

	UGameReplay_StopRecordingReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.StopPlay
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::StopPlay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.StopPlay");

	UGameReplay_StopPlay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.StartRecordingReplay
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::StartRecordingReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.StartRecordingReplay");

	UGameReplay_StartRecordingReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.SetSpectatorName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 SpectatorName                  (Parm, ZeroConstructor)
// bool                           bGM                            (Parm, ZeroConstructor, IsPlainOldData)

void UGameReplay::SetSpectatorName(const struct FString& SpectatorName, bool bGM)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.SetSpectatorName");

	UGameReplay_SetSpectatorName_Params params;
	params.SpectatorName = SpectatorName;
	params.bGM = bGM;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameReplay.SetIsGMSpectator
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bGM                            (Parm, ZeroConstructor, IsPlainOldData)

void UGameReplay::SetIsGMSpectator(bool bGM)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.SetIsGMSpectator");

	UGameReplay_SetIsGMSpectator_Params params;
	params.bGM = bGM;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameReplay.SetCurrentReplayTimeToSeconds
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Seconds                        (Parm, ZeroConstructor, IsPlainOldData)

void UGameReplay::SetCurrentReplayTimeToSeconds(float Seconds)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.SetCurrentReplayTimeToSeconds");

	UGameReplay_SetCurrentReplayTimeToSeconds_Params params;
	params.Seconds = Seconds;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameReplay.PlayReplay
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::PlayReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.PlayReplay");

	UGameReplay_PlayReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.PauseReplay
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           bPaused                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::PauseReplay(bool bPaused)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.PauseReplay");

	UGameReplay_PauseReplay_Params params;
	params.bPaused = bPaused;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.IsInRecordState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::IsInRecordState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.IsInRecordState");

	UGameReplay_IsInRecordState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.IsInPlayState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::IsInPlayState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.IsInPlayState");

	UGameReplay_IsInPlayState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.HaveRecordingData
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameReplay::HaveRecordingData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.HaveRecordingData");

	UGameReplay_HaveRecordingData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.GetSpectatorName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UGameReplay::GetSpectatorName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.GetSpectatorName");

	UGameReplay_GetSpectatorName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.GetCurrentReplayTotalTimeInSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UGameReplay::GetCurrentReplayTotalTimeInSeconds()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.GetCurrentReplayTotalTimeInSeconds");

	UGameReplay_GetCurrentReplayTotalTimeInSeconds_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameReplay.GetCurrentReplayCurTimeInSeconds
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UGameReplay::GetCurrentReplayCurTimeInSeconds()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameReplay.GetCurrentReplayCurTimeInSeconds");

	UGameReplay_GetCurrentReplayCurTimeInSeconds_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CompletePlayback.Refresh_TeammatePlayerState
// (Final, Native, Public)

void UCompletePlayback::Refresh_TeammatePlayerState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CompletePlayback.Refresh_TeammatePlayerState");

	UCompletePlayback_Refresh_TeammatePlayerState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CompletePlayback.PlayDemoWithFilename
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 DemoName                       (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UCompletePlayback::PlayDemoWithFilename(const struct FString& DemoName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CompletePlayback.PlayDemoWithFilename");

	UCompletePlayback_PlayDemoWithFilename_Params params;
	params.DemoName = DemoName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CrossHairComponent.DrawSpreadEnd
// (Final, Native, Protected)

void UCrossHairComponent::DrawSpreadEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrossHairComponent.DrawSpreadEnd");

	UCrossHairComponent_DrawSpreadEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrossHairComponent.DrawDebugPointEnd
// (Final, Native, Protected)

void UCrossHairComponent::DrawDebugPointEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrossHairComponent.DrawDebugPointEnd");

	UCrossHairComponent_DrawDebugPointEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdAgentComponent.StopMove
// (Final, Native, Public, BlueprintCallable)

void UCrowdAgentComponent::StopMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdAgentComponent.StopMove");

	UCrowdAgentComponent_StopMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdAgentComponent.MoveToLoc
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UCrowdAgentComponent::MoveToLoc(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdAgentComponent.MoveToLoc");

	UCrowdAgentComponent_MoveToLoc_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdAgentComponent.MoveToActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Actor                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData)

void UCrowdAgentComponent::MoveToActor(class AActor* Actor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdAgentComponent.MoveToActor");

	UCrowdAgentComponent_MoveToActor_Params params;
	params.Actor = Actor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdManagerComponent.SetQueryInterfaceBlueprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AAIWorldVolume*          query                          (Parm, ZeroConstructor, IsPlainOldData)

void UCrowdManagerComponent::SetQueryInterfaceBlueprint(class AAIWorldVolume* query)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdManagerComponent.SetQueryInterfaceBlueprint");

	UCrowdManagerComponent_SetQueryInterfaceBlueprint_Params params;
	params.query = query;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdManagerComponent.RemoveCrowdAgentBlueprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Owner                          (Parm, ZeroConstructor, IsPlainOldData)

void UCrowdManagerComponent::RemoveCrowdAgentBlueprint(class AActor* Owner)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdManagerComponent.RemoveCrowdAgentBlueprint");

	UCrowdManagerComponent_RemoveCrowdAgentBlueprint_Params params;
	params.Owner = Owner;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdManagerComponent.MoveToPositionBlueprint
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                  Agent                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Position                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          stopRadius                     (Parm, ZeroConstructor, IsPlainOldData)

void UCrowdManagerComponent::MoveToPositionBlueprint(class AActor* Agent, const struct FVector& Position, float stopRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdManagerComponent.MoveToPositionBlueprint");

	UCrowdManagerComponent_MoveToPositionBlueprint_Params params;
	params.Agent = Agent;
	params.Position = Position;
	params.stopRadius = stopRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CrowdManagerComponent.AddCrowdAgentBlueprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Owner                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          AgentRadius                    (Parm, ZeroConstructor, IsPlainOldData)
// float                          segmentRadius                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaxSpeed                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaxForce                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          queryNeighborRadius            (Parm, ZeroConstructor, IsPlainOldData)
// float                          queryBoundaryRadius            (Parm, ZeroConstructor, IsPlainOldData)

void UCrowdManagerComponent::AddCrowdAgentBlueprint(class AActor* Owner, float AgentRadius, float segmentRadius, float Height, float MaxSpeed, float MaxForce, float queryNeighborRadius, float queryBoundaryRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CrowdManagerComponent.AddCrowdAgentBlueprint");

	UCrowdManagerComponent_AddCrowdAgentBlueprint_Params params;
	params.Owner = Owner;
	params.AgentRadius = AgentRadius;
	params.segmentRadius = segmentRadius;
	params.Height = Height;
	params.MaxSpeed = MaxSpeed;
	params.MaxForce = MaxForce;
	params.queryNeighborRadius = queryNeighborRadius;
	params.queryBoundaryRadius = queryBoundaryRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomParticleSystemComponent.AddCollisionIgnoreActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  ignoreActor                    (Parm, ZeroConstructor, IsPlainOldData)

void UCustomParticleSystemComponent::AddCollisionIgnoreActor(class AActor* ignoreActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomParticleSystemComponent.AddCollisionIgnoreActor");

	UCustomParticleSystemComponent_AddCollisionIgnoreActor_Params params;
	params.ignoreActor = ignoreActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetScrollOffset
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          NewScrollOffset                (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::SetScrollOffset(float NewScrollOffset)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetScrollOffset");

	UCustomScrollBox_SetScrollOffset_Params params;
	params.NewScrollOffset = NewScrollOffset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetScrollBarVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESlateVisibility               NewScrollBarVisibility         (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::SetScrollBarVisibility(ESlateVisibility NewScrollBarVisibility)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetScrollBarVisibility");

	UCustomScrollBox_SetScrollBarVisibility_Params params;
	params.NewScrollBarVisibility = NewScrollBarVisibility;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetScrollbarThickness
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               NewScrollbarThickness          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UCustomScrollBox::SetScrollbarThickness(const struct FVector2D& NewScrollbarThickness)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetScrollbarThickness");

	UCustomScrollBox_SetScrollbarThickness_Params params;
	params.NewScrollbarThickness = NewScrollbarThickness;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetOrientation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EOrientation>      NewOrientation                 (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::SetOrientation(TEnumAsByte<EOrientation> NewOrientation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetOrientation");

	UCustomScrollBox_SetOrientation_Params params;
	params.NewOrientation = NewOrientation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetAlwaysShowScrollbar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           NewAlwaysShowScrollbar         (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::SetAlwaysShowScrollbar(bool NewAlwaysShowScrollbar)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetAlwaysShowScrollbar");

	UCustomScrollBox_SetAlwaysShowScrollbar_Params params;
	params.NewAlwaysShowScrollbar = NewAlwaysShowScrollbar;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.SetAllowOverscroll
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           NewAllowOverscroll             (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::SetAllowOverscroll(bool NewAllowOverscroll)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.SetAllowOverscroll");

	UCustomScrollBox_SetAllowOverscroll_Params params;
	params.NewAllowOverscroll = NewAllowOverscroll;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.ScrollWidgetIntoView
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWidget*                 WidgetToFind                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           AnimateScroll                  (Parm, ZeroConstructor, IsPlainOldData)
// EDescendantScrollDestination   ScrollDesintion                (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBox::ScrollWidgetIntoView(class UWidget* WidgetToFind, bool AnimateScroll, EDescendantScrollDestination ScrollDesintion)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.ScrollWidgetIntoView");

	UCustomScrollBox_ScrollWidgetIntoView_Params params;
	params.WidgetToFind = WidgetToFind;
	params.AnimateScroll = AnimateScroll;
	params.ScrollDesintion = ScrollDesintion;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.ScrollToStart
// (Final, Native, Public, BlueprintCallable)

void UCustomScrollBox::ScrollToStart()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.ScrollToStart");

	UCustomScrollBox_ScrollToStart_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.ScrollToEnd
// (Final, Native, Public, BlueprintCallable)

void UCustomScrollBox::ScrollToEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.ScrollToEnd");

	UCustomScrollBox_ScrollToEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.ScrollStop
// (Final, Native, Public, BlueprintCallable)

void UCustomScrollBox::ScrollStop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.ScrollStop");

	UCustomScrollBox_ScrollStop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBox.GetScrollOffset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UCustomScrollBox::GetScrollOffset()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.GetScrollOffset");

	UCustomScrollBox_GetScrollOffset_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CustomScrollBox.GetMaxScrollOffset
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UCustomScrollBox::GetMaxScrollOffset()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBox.GetMaxScrollOffset");

	UCustomScrollBox_GetMaxScrollOffset_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.CustomScrollBoxSlot.SetPadding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FMargin                 InPadding                      (Parm)

void UCustomScrollBoxSlot::SetPadding(const struct FMargin& InPadding)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBoxSlot.SetPadding");

	UCustomScrollBoxSlot_SetPadding_Params params;
	params.InPadding = InPadding;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomScrollBoxSlot.SetHorizontalAlignment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment          (Parm, ZeroConstructor, IsPlainOldData)

void UCustomScrollBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomScrollBoxSlot.SetHorizontalAlignment");

	UCustomScrollBoxSlot_SetHorizontalAlignment_Params params;
	params.InHorizontalAlignment = InHorizontalAlignment;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSpringArmComponent.ClearCameraData
// (Native, Public, BlueprintCallable)

void USTExtraSpringArmComponent::ClearCameraData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSpringArmComponent.ClearCameraData");

	USTExtraSpringArmComponent_ClearCameraData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomSpringArmComponent.SetCameraDataEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ECameraDataType>   CameraDataType                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void UCustomSpringArmComponent::SetCameraDataEnable(TEnumAsByte<ECameraDataType> CameraDataType, bool IsEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomSpringArmComponent.SetCameraDataEnable");

	UCustomSpringArmComponent_SetCameraDataEnable_Params params;
	params.CameraDataType = CameraDataType;
	params.IsEnable = IsEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomSpringArmComponent.ForceUpdateDesiredArmLocation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bDoTrace                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bDoLocationLag                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bDoRotationLag                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UCustomSpringArmComponent::ForceUpdateDesiredArmLocation(bool bDoTrace, bool bDoLocationLag, bool bDoRotationLag, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomSpringArmComponent.ForceUpdateDesiredArmLocation");

	UCustomSpringArmComponent_ForceUpdateDesiredArmLocation_Params params;
	params.bDoTrace = bDoTrace;
	params.bDoLocationLag = bDoLocationLag;
	params.bDoRotationLag = bDoRotationLag;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomSpringArmComponent.DelayRotationLagEnabledEnd
// (Final, Native, Protected)

void UCustomSpringArmComponent::DelayRotationLagEnabledEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomSpringArmComponent.DelayRotationLagEnabledEnd");

	UCustomSpringArmComponent_DelayRotationLagEnabledEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.CustomSpringArmComponent.DelayRotationLagEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)

void UCustomSpringArmComponent::DelayRotationLagEnabled(bool bEnabled, float Time)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.CustomSpringArmComponent.DelayRotationLagEnabled");

	UCustomSpringArmComponent_DelayRotationLagEnabled_Params params;
	params.bEnabled = bEnabled;
	params.Time = Time;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DamageableInterface.JudgeComponentBlockBullet
// (Native, Public)
// Parameters:
// class UPrimitiveComponent*     Comp                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDamageableInterface::JudgeComponentBlockBullet(class UPrimitiveComponent* Comp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.JudgeComponentBlockBullet");

	UDamageableInterface_JudgeComponentBlockBullet_Params params;
	params.Comp = Comp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetPickingBoundingBox
// (Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FVector                 Center                         (Parm, OutParm, IsPlainOldData)
// struct FVector                 Extent                         (Parm, OutParm, IsPlainOldData)
// struct FRotator                Rotation                       (Parm, OutParm, IsPlainOldData)
// float                          Distance                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDamageableInterface::GetPickingBoundingBox(struct FVector* Center, struct FVector* Extent, struct FRotator* Rotation, float* Distance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetPickingBoundingBox");

	UDamageableInterface_GetPickingBoundingBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (Center != nullptr)
		*Center = params.Center;
	if (Extent != nullptr)
		*Extent = params.Extent;
	if (Rotation != nullptr)
		*Rotation = params.Rotation;
	if (Distance != nullptr)
		*Distance = params.Distance;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetDamageRateFromDamageEvent
// (Native, Public, HasOutParms)
// Parameters:
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UDamageableInterface::GetDamageRateFromDamageEvent(const struct FDamageEvent& DamageEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetDamageRateFromDamageEvent");

	UDamageableInterface_GetDamageRateFromDamageEvent_Params params;
	params.DamageEvent = DamageEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetDamageRateByTarget
// (Native, Public)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UDamageableInterface::GetDamageRateByTarget(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetDamageRateByTarget");

	UDamageableInterface_GetDamageRateByTarget_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetDamageableGameObjectType
// (Native, Public, Const)
// Parameters:
// TArray<EDamageableGameObjectType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<EDamageableGameObjectType> UDamageableInterface::GetDamageableGameObjectType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetDamageableGameObjectType");

	UDamageableInterface_GetDamageableGameObjectType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetCanBePicked
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDamageableInterface::GetCanBePicked()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetCanBePicked");

	UDamageableInterface_GetCanBePicked_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetBulletBlockComponentTag
// (Native, Public)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UDamageableInterface::GetBulletBlockComponentTag()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetBulletBlockComponentTag");

	UDamageableInterface_GetBulletBlockComponentTag_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.GetAdditionaAbsoluteDamageFromDamageEvent
// (Native, Public, HasOutParms)
// Parameters:
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UDamageableInterface::GetAdditionaAbsoluteDamageFromDamageEvent(const struct FDamageEvent& DamageEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.GetAdditionaAbsoluteDamageFromDamageEvent");

	UDamageableInterface_GetAdditionaAbsoluteDamageFromDamageEvent_Params params;
	params.DamageEvent = DamageEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DamageableInterface.CalcFinalDamageRate
// (Native, Public, HasOutParms)
// Parameters:
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// class AActor*                  Attacker                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UDamageableInterface::CalcFinalDamageRate(const struct FDamageEvent& DamageEvent, class AActor* Attacker)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DamageableInterface.CalcFinalDamageRate");

	UDamageableInterface_CalcFinalDamageRate_Params params;
	params.DamageEvent = DamageEvent;
	params.Attacker = Attacker;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.HUDWidgetBase.ShouldDraw
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           bShowScores                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UHUDWidgetBase::ShouldDraw(bool bShowScores)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.ShouldDraw");

	UHUDWidgetBase_ShouldDraw_Params params;
	params.bShowScores = bShowScores;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.HUDWidgetBase.SetHidden
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           bIsHidden                      (Parm, ZeroConstructor, IsPlainOldData)

void UHUDWidgetBase::SetHidden(bool bIsHidden)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.SetHidden");

	UHUDWidgetBase_SetHidden_Params params;
	params.bIsHidden = bIsHidden;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_TextureAt
// (Native, Protected, HasOutParms, BlueprintCallable)
// Parameters:
// struct FHUDRenderObject_Texture TextureObject                  (Parm, OutParm)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Width                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)

void UHUDWidgetBase::RenderObj_TextureAt(float X, float Y, float Width, float Height, struct FHUDRenderObject_Texture* TextureObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_TextureAt");

	UHUDWidgetBase_RenderObj_TextureAt_Params params;
	params.X = X;
	params.Y = Y;
	params.Width = Width;
	params.Height = Height;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (TextureObject != nullptr)
		*TextureObject = params.TextureObject;
}


// Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_Texture
// (Native, Protected, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FHUDRenderObject_Texture TextureObject                  (Parm, OutParm)
// struct FVector2D               DrawOffset                     (Parm, IsPlainOldData)

void UHUDWidgetBase::RenderObj_Texture(const struct FVector2D& DrawOffset, struct FHUDRenderObject_Texture* TextureObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_Texture");

	UHUDWidgetBase_RenderObj_Texture_Params params;
	params.DrawOffset = DrawOffset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (TextureObject != nullptr)
		*TextureObject = params.TextureObject;
}


// Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_TextAt
// (Native, Protected, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FHUDRenderObject_Text   TextObject                     (Parm, OutParm)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D UHUDWidgetBase::RenderObj_TextAt(float X, float Y, struct FHUDRenderObject_Text* TextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_TextAt");

	UHUDWidgetBase_RenderObj_TextAt_Params params;
	params.X = X;
	params.Y = Y;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (TextObject != nullptr)
		*TextObject = params.TextObject;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_Text
// (Native, Protected, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FHUDRenderObject_Text   TextObject                     (Parm, OutParm)
// struct FVector2D               DrawOffset                     (Parm, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D UHUDWidgetBase::RenderObj_Text(const struct FVector2D& DrawOffset, struct FHUDRenderObject_Text* TextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.RenderObj_Text");

	UHUDWidgetBase_RenderObj_Text_Params params;
	params.DrawOffset = DrawOffset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (TextObject != nullptr)
		*TextObject = params.TextObject;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.HUDWidgetBase.DrawTexture
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UTexture*                Texture                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Width                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialU                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialV                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialUL                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialVL                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          DrawOpacity                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DrawColor                      (Parm, IsPlainOldData)
// struct FVector2D               RenderOffset                   (Parm, IsPlainOldData)
// float                          Rotation                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               RotPivot                       (Parm, IsPlainOldData)

void UHUDWidgetBase::DrawTexture(class UTexture* Texture, float X, float Y, float Width, float Height, float MaterialU, float MaterialV, float MaterialUL, float MaterialVL, float DrawOpacity, const struct FLinearColor& DrawColor, const struct FVector2D& RenderOffset, float Rotation, const struct FVector2D& RotPivot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.DrawTexture");

	UHUDWidgetBase_DrawTexture_Params params;
	params.Texture = Texture;
	params.X = X;
	params.Y = Y;
	params.Width = Width;
	params.Height = Height;
	params.MaterialU = MaterialU;
	params.MaterialV = MaterialV;
	params.MaterialUL = MaterialUL;
	params.MaterialVL = MaterialVL;
	params.DrawOpacity = DrawOpacity;
	params.DrawColor = DrawColor;
	params.RenderOffset = RenderOffset;
	params.Rotation = Rotation;
	params.RotPivot = RotPivot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.HUDWidgetBase.DrawText
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FText                   Text                           (Parm)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// class UFont*                   Font                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bDrawShadow                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ShadowDirection                (Parm, IsPlainOldData)
// struct FLinearColor            ShadowColor                    (Parm, IsPlainOldData)
// bool                           bDrawOutline                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            OutlineColor                   (Parm, IsPlainOldData)
// float                          TextScale                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          DrawOpacity                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DrawColor                      (Parm, IsPlainOldData)
// TEnumAsByte<ETextHorzPos>      TextHorzAlignment              (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETextVertPos>      TextVertAlignment              (Parm, ZeroConstructor, IsPlainOldData)
// struct FFontRenderInfo         RenderInfo                     (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D UHUDWidgetBase::DrawText(const struct FText& Text, float X, float Y, class UFont* Font, bool bDrawShadow, const struct FVector2D& ShadowDirection, const struct FLinearColor& ShadowColor, bool bDrawOutline, const struct FLinearColor& OutlineColor, float TextScale, float DrawOpacity, const struct FLinearColor& DrawColor, TEnumAsByte<ETextHorzPos> TextHorzAlignment, TEnumAsByte<ETextVertPos> TextVertAlignment, const struct FFontRenderInfo& RenderInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.DrawText");

	UHUDWidgetBase_DrawText_Params params;
	params.Text = Text;
	params.X = X;
	params.Y = Y;
	params.Font = Font;
	params.bDrawShadow = bDrawShadow;
	params.ShadowDirection = ShadowDirection;
	params.ShadowColor = ShadowColor;
	params.bDrawOutline = bDrawOutline;
	params.OutlineColor = OutlineColor;
	params.TextScale = TextScale;
	params.DrawOpacity = DrawOpacity;
	params.DrawColor = DrawColor;
	params.TextHorzAlignment = TextHorzAlignment;
	params.TextVertAlignment = TextVertAlignment;
	params.RenderInfo = RenderInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.HUDWidgetBase.DrawMaterial
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UMaterialInterface*      Material                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Width                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialU                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialV                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialUWidth                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaterialVHeight                (Parm, ZeroConstructor, IsPlainOldData)
// float                          DrawOpacity                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DrawColor                      (Parm, IsPlainOldData)
// struct FVector2D               RenderOffset                   (Parm, IsPlainOldData)
// float                          Rotation                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               RotPivot                       (Parm, IsPlainOldData)

void UHUDWidgetBase::DrawMaterial(class UMaterialInterface* Material, float X, float Y, float Width, float Height, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float DrawOpacity, const struct FLinearColor& DrawColor, const struct FVector2D& RenderOffset, float Rotation, const struct FVector2D& RotPivot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.DrawMaterial");

	UHUDWidgetBase_DrawMaterial_Params params;
	params.Material = Material;
	params.X = X;
	params.Y = Y;
	params.Width = Width;
	params.Height = Height;
	params.MaterialU = MaterialU;
	params.MaterialV = MaterialV;
	params.MaterialUWidth = MaterialUWidth;
	params.MaterialVHeight = MaterialVHeight;
	params.DrawOpacity = DrawOpacity;
	params.DrawColor = DrawColor;
	params.RenderOffset = RenderOffset;
	params.Rotation = Rotation;
	params.RotPivot = RotPivot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.HUDWidgetBase.DrawAllRenderObjects
// (Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               DrawOffset                     (Parm, IsPlainOldData)

void UHUDWidgetBase::DrawAllRenderObjects(float DeltaTime, const struct FVector2D& DrawOffset)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.DrawAllRenderObjects");

	UHUDWidgetBase_DrawAllRenderObjects_Params params;
	params.DeltaTime = DeltaTime;
	params.DrawOffset = DrawOffset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.HUDWidgetBase.Draw
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UHUDWidgetBase::Draw(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.Draw");

	UHUDWidgetBase_Draw_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.HUDWidgetBase.ApplyHUDColor
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FLinearColor            DrawColor                      (Parm, IsPlainOldData)
// struct FLinearColor            ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FLinearColor UHUDWidgetBase::ApplyHUDColor(const struct FLinearColor& DrawColor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.HUDWidgetBase.ApplyHUDColor");

	UHUDWidgetBase_ApplyHUDColor_Params params;
	params.DrawColor = DrawColor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DataTableManager.GetTableByType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<EDataTableType>    TableType                      (Parm, ZeroConstructor, IsPlainOldData)
// class UDataTable*              ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UDataTable* UDataTableManager::GetTableByType(TEnumAsByte<EDataTableType> TableType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DataTableManager.GetTableByType");

	UDataTableManager_GetTableByType_Params params;
	params.TableType = TableType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DataTableManager.GetInstance
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UDataTableManager*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UDataTableManager* UDataTableManager::GetInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DataTableManager.GetInstance");

	UDataTableManager_GetInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DayToNightActor.TrytoFireEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            EventID                        (Parm, ZeroConstructor, IsPlainOldData)

void ADayToNightActor::TrytoFireEvent(int EventID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DayToNightActor.TrytoFireEvent");

	ADayToNightActor_TrytoFireEvent_Params params;
	params.EventID = EventID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DayToNightActor.SetNightVisionOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bOpen                          (Parm, ZeroConstructor, IsPlainOldData)

void ADayToNightActor::SetNightVisionOpen(bool bOpen)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DayToNightActor.SetNightVisionOpen");

	ADayToNightActor_SetNightVisionOpen_Params params;
	params.bOpen = bOpen;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DayToNightActor.FireEvent
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            EventID                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            EventParam                     (Parm, ZeroConstructor, IsPlainOldData)

void ADayToNightActor::FireEvent(int EventID, int EventParam)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DayToNightActor.FireEvent");

	ADayToNightActor_FireEvent_Params params;
	params.EventID = EventID;
	params.EventParam = EventParam;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DayToNightActor.BP_ClientOnFireEvent
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            EventID                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            EventParam                     (Parm, ZeroConstructor, IsPlainOldData)

void ADayToNightActor::BP_ClientOnFireEvent(int EventID, int EventParam)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DayToNightActor.BP_ClientOnFireEvent");

	ADayToNightActor_BP_ClientOnFireEvent_Params params;
	params.EventID = EventID;
	params.EventParam = EventParam;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DeathPlayback.IsSwitchedOffByDevice
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDeathPlayback::IsSwitchedOffByDevice()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DeathPlayback.IsSwitchedOffByDevice");

	UDeathPlayback_IsSwitchedOffByDevice_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DeathPlayback.EnableDeathPlayback
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void UDeathPlayback::EnableDeathPlayback(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DeathPlayback.EnableDeathPlayback");

	UDeathPlayback_EnableDeathPlayback_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DelayFlyProjMovementComponent.StartFly
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 flyVelocity                    (Parm, IsPlainOldData)
// bool                           isThrowHigh                    (Parm, ZeroConstructor, IsPlainOldData)

void UDelayFlyProjMovementComponent::StartFly(const struct FVector& flyVelocity, bool isThrowHigh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DelayFlyProjMovementComponent.StartFly");

	UDelayFlyProjMovementComponent_StartFly_Params params;
	params.flyVelocity = flyVelocity;
	params.isThrowHigh = isThrowHigh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DelayFlyProjMovementComponent.ResumeMoveAfterImpactWithNoLost
// (Final, Native, Public, BlueprintCallable)

void UDelayFlyProjMovementComponent::ResumeMoveAfterImpactWithNoLost()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DelayFlyProjMovementComponent.ResumeMoveAfterImpactWithNoLost");

	UDelayFlyProjMovementComponent_ResumeMoveAfterImpactWithNoLost_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DrivingChallengeLevelRules.ValidNewCheckPoint
// (Final, Native, Private)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UDrivingChallengeLevelRules::ValidNewCheckPoint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DrivingChallengeLevelRules.ValidNewCheckPoint");

	UDrivingChallengeLevelRules_ValidNewCheckPoint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.DrivingChallengeLevelRules.SignCheckPointPassed
// (Final, Native, Private)
// Parameters:
// struct FString                 Msg                            (Parm, ZeroConstructor)

void UDrivingChallengeLevelRules::SignCheckPointPassed(const struct FString& Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DrivingChallengeLevelRules.SignCheckPointPassed");

	UDrivingChallengeLevelRules_SignCheckPointPassed_Params params;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DrivingChallengeLevelRules.SignAndSetDrivingCheckPoint
// (Final, Native, Private)
// Parameters:
// struct FString                 Msg                            (Parm, ZeroConstructor)

void UDrivingChallengeLevelRules::SignAndSetDrivingCheckPoint(const struct FString& Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DrivingChallengeLevelRules.SignAndSetDrivingCheckPoint");

	UDrivingChallengeLevelRules_SignAndSetDrivingCheckPoint_Params params;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DrivingChallengeLevelRules.OnReceiveTriggerMsg
// (Native, Public)
// Parameters:
// class UTriggerAction*          TriggerAction                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Msg                            (Parm, ZeroConstructor)

void UDrivingChallengeLevelRules::OnReceiveTriggerMsg(class UTriggerAction* TriggerAction, const struct FString& Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DrivingChallengeLevelRules.OnReceiveTriggerMsg");

	UDrivingChallengeLevelRules_OnReceiveTriggerMsg_Params params;
	params.TriggerAction = TriggerAction;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DrivingChallengeLevelRules.InitLevel
// (Native, Public)

void UDrivingChallengeLevelRules::InitLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DrivingChallengeLevelRules.InitLevel");

	UDrivingChallengeLevelRules_InitLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherController.OnUserQualitySettingChanged
// (Native, Protected)
// Parameters:
// int                            renderlevel                    (Parm, ZeroConstructor, IsPlainOldData)

void UDynamicWeatherController::OnUserQualitySettingChanged(int renderlevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherController.OnUserQualitySettingChanged");

	UDynamicWeatherController_OnUserQualitySettingChanged_Params params;
	params.renderlevel = renderlevel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicRainController.OnUserQualitySettingChanged
// (Native, Public)
// Parameters:
// int                            renderlevel                    (Parm, ZeroConstructor, IsPlainOldData)

void UDynamicRainController::OnUserQualitySettingChanged(int renderlevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicRainController.OnUserQualitySettingChanged");

	UDynamicRainController_OnUserQualitySettingChanged_Params params;
	params.renderlevel = renderlevel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicRainController.CreateThunderOnServer
// (Final, Native, Public)

void UDynamicRainController::CreateThunderOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicRainController.CreateThunderOnServer");

	UDynamicRainController_CreateThunderOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicRainController.CreateThunderOnClient
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// float                          angle                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Distance                       (Parm, ZeroConstructor, IsPlainOldData)

void UDynamicRainController::CreateThunderOnClient(float angle, float Distance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicRainController.CreateThunderOnClient");

	UDynamicRainController_CreateThunderOnClient_Params params;
	params.angle = angle;
	params.Distance = Distance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.StartTransition
// (Final, Native, Private)

void ADynamicWeatherMgr::StartTransition()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.StartTransition");

	ADynamicWeatherMgr_StartTransition_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.SoftReconnectRecoverData
// (Final, Native, Private)
// Parameters:
// class AUAEPlayerController*    PC                             (Parm, ZeroConstructor, IsPlainOldData)

void ADynamicWeatherMgr::SoftReconnectRecoverData(class AUAEPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.SoftReconnectRecoverData");

	ADynamicWeatherMgr_SoftReconnectRecoverData_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.RPCRequireControl
// (Final, Native, Private)

void ADynamicWeatherMgr::RPCRequireControl()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.RPCRequireControl");

	ADynamicWeatherMgr_RPCRequireControl_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.RPCRequire
// (Final, Native, Private)

void ADynamicWeatherMgr::RPCRequire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.RPCRequire");

	ADynamicWeatherMgr_RPCRequire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeStarted
// (Final, Native, Private)

void ADynamicWeatherMgr::OnWeatherChangeStarted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeStarted");

	ADynamicWeatherMgr_OnWeatherChangeStarted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeSaturated
// (Final, Native, Private)

void ADynamicWeatherMgr::OnWeatherChangeSaturated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeSaturated");

	ADynamicWeatherMgr_OnWeatherChangeSaturated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeRestoreStarted
// (Final, Native, Private)

void ADynamicWeatherMgr::OnWeatherChangeRestoreStarted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeRestoreStarted");

	ADynamicWeatherMgr_OnWeatherChangeRestoreStarted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeRestoreEnded
// (Final, Native, Private)

void ADynamicWeatherMgr::OnWeatherChangeRestoreEnded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnWeatherChangeRestoreEnded");

	ADynamicWeatherMgr_OnWeatherChangeRestoreEnded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnRep_ControllerDataForReplay
// (Final, Native, Private)

void ADynamicWeatherMgr::OnRep_ControllerDataForReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnRep_ControllerDataForReplay");

	ADynamicWeatherMgr_OnRep_ControllerDataForReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.OnRep_ControllerData
// (Final, Native, Private)

void ADynamicWeatherMgr::OnRep_ControllerData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.OnRep_ControllerData");

	ADynamicWeatherMgr_OnRep_ControllerData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.HandleClientHasReactivated
// (Final, Native, Private)

void ADynamicWeatherMgr::HandleClientHasReactivated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.HandleClientHasReactivated");

	ADynamicWeatherMgr_HandleClientHasReactivated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.DynamicWeatherMgr.ClientInit
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// struct FWeatherControllerRepData InitDataIn                     (Parm)

void ADynamicWeatherMgr::ClientInit(const struct FWeatherControllerRepData& InitDataIn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.DynamicWeatherMgr.ClientInit");

	ADynamicWeatherMgr_ClientInit_Params params;
	params.InitDataIn = InitDataIn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EffectComponent.S2Sim_CallRemoteEffect
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            graphTid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            graphUid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            effectTid                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Source                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// TArray<unsigned char>          Data                           (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void UEffectComponent::S2Sim_CallRemoteEffect(int graphTid, int graphUid, int effectTid, class AActor* Source, class AActor* Target, TArray<unsigned char> Data)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EffectComponent.S2Sim_CallRemoteEffect");

	UEffectComponent_S2Sim_CallRemoteEffect_Params params;
	params.graphTid = graphTid;
	params.graphUid = graphUid;
	params.effectTid = effectTid;
	params.Source = Source;
	params.Target = Target;
	params.Data = Data;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EffectComponent.S2C_CallRemoteEffect
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            graphTid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            graphUid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            effectTid                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Source                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// TArray<unsigned char>          Data                           (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void UEffectComponent::S2C_CallRemoteEffect(int graphTid, int graphUid, int effectTid, class AActor* Source, class AActor* Target, TArray<unsigned char> Data)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EffectComponent.S2C_CallRemoteEffect");

	UEffectComponent_S2C_CallRemoteEffect_Params params;
	params.graphTid = graphTid;
	params.graphUid = graphUid;
	params.effectTid = effectTid;
	params.Source = Source;
	params.Target = Target;
	params.Data = Data;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EffectComponent.S2A_EndEffectGraph
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            UID                            (Parm, ZeroConstructor, IsPlainOldData)

void UEffectComponent::S2A_EndEffectGraph(int UID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EffectComponent.S2A_EndEffectGraph");

	UEffectComponent_S2A_EndEffectGraph_Params params;
	params.UID = UID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EffectComponent.C2S_CallRemoteEffect
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            graphTid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            graphUid                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            effectTid                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Source                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// TArray<unsigned char>          Data                           (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void UEffectComponent::C2S_CallRemoteEffect(int graphTid, int graphUid, int effectTid, class AActor* Source, class AActor* Target, TArray<unsigned char> Data)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EffectComponent.C2S_CallRemoteEffect");

	UEffectComponent_C2S_CallRemoteEffect_Params params;
	params.graphTid = graphTid;
	params.graphUid = graphUid;
	params.effectTid = effectTid;
	params.Source = Source;
	params.Target = Target;
	params.Data = Data;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.UpdatePlayersLocAndRotC
// (Final, Native, Private)

void UEntireMapWidget::UpdatePlayersLocAndRotC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.UpdatePlayersLocAndRotC");

	UEntireMapWidget_UpdatePlayersLocAndRotC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.UpdateMarkerDistanceC
// (Event, Protected, BlueprintEvent)

void UEntireMapWidget::UpdateMarkerDistanceC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.UpdateMarkerDistanceC");

	UEntireMapWidget_UpdateMarkerDistanceC_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.UpdateLeftRouteLengthC
// (Final, Native, Private)

void UEntireMapWidget::UpdateLeftRouteLengthC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.UpdateLeftRouteLengthC");

	UEntireMapWidget_UpdateLeftRouteLengthC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.UpdateLastDriveVehicleC
// (Final, Native, Private)

void UEntireMapWidget::UpdateLastDriveVehicleC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.UpdateLastDriveVehicleC");

	UEntireMapWidget_UpdateLastDriveVehicleC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.UpdateAirIconC
// (Final, Native, Private)

void UEntireMapWidget::UpdateAirIconC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.UpdateAirIconC");

	UEntireMapWidget_UpdateAirIconC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.TickCircleC
// (Final, Native, Private)

void UEntireMapWidget::TickCircleC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.TickCircleC");

	UEntireMapWidget_TickCircleC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.RepositionItemOnMapC
// (Event, Protected, BlueprintEvent)

void UEntireMapWidget::RepositionItemOnMapC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.RepositionItemOnMapC");

	UEntireMapWidget_RepositionItemOnMapC_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.ReCalMapInfoC
// (Final, Native, Protected, BlueprintCallable)

void UEntireMapWidget::ReCalMapInfoC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.ReCalMapInfoC");

	UEntireMapWidget_ReCalMapInfoC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EntireMapWidget.MapResizeC
// (Event, Protected, BlueprintEvent)

void UEntireMapWidget::MapResizeC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EntireMapWidget.MapResizeC");

	UEntireMapWidget_MapResizeC_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EquipmentBoxActor.UpdateEquipCountMax
// (Final, Native, Private)

void AEquipmentBoxActor::UpdateEquipCountMax()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EquipmentBoxActor.UpdateEquipCountMax");

	AEquipmentBoxActor_UpdateEquipCountMax_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EquipmentBoxActor.UpdateEquipCountCurrent
// (Final, Native, Private)

void AEquipmentBoxActor::UpdateEquipCountCurrent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EquipmentBoxActor.UpdateEquipCountCurrent");

	AEquipmentBoxActor_UpdateEquipCountCurrent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.EquipmentBoxActor.ModifyPickUpItemDatas
// (Final, Native, Private)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AEquipmentBoxActor::ModifyPickUpItemDatas()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EquipmentBoxActor.ModifyPickUpItemDatas");

	AEquipmentBoxActor_ModifyPickUpItemDatas_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.EquipmentBoxActor.MakePickUpItemDatas
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<struct FPickUpItemData> DataList                       (Parm, OutParm, ZeroConstructor)

void AEquipmentBoxActor::MakePickUpItemDatas(TArray<struct FPickUpItemData>* DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.EquipmentBoxActor.MakePickUpItemDatas");

	AEquipmentBoxActor_MakePickUpItemDatas_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DataList != nullptr)
		*DataList = params.DataList;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.SetCurResObjState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETRWResObjectState> InState                        (Parm, ZeroConstructor, IsPlainOldData)

void AExtraTeamRWResActor::SetCurResObjState(TEnumAsByte<ETRWResObjectState> InState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.SetCurResObjState");

	AExtraTeamRWResActor_SetCurResObjState_Params params;
	params.InState = InState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.PlayerIsInMyInside
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Pawn                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AExtraTeamRWResActor::PlayerIsInMyInside(class ASTExtraBaseCharacter* Pawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.PlayerIsInMyInside");

	AExtraTeamRWResActor_PlayerIsInMyInside_Params params;
	params.Pawn = Pawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_ResID
// (Final, Native, Public)

void AExtraTeamRWResActor::OnRep_ResID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_ResID");

	AExtraTeamRWResActor_OnRep_ResID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_DisplayName
// (Final, Native, Public)

void AExtraTeamRWResActor::OnRep_DisplayName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_DisplayName");

	AExtraTeamRWResActor_OnRep_DisplayName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentResObjState
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETRWResObjectState> LastState                      (Parm, ZeroConstructor, IsPlainOldData)

void AExtraTeamRWResActor::OnRep_CurrentResObjState(TEnumAsByte<ETRWResObjectState> LastState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentResObjState");

	AExtraTeamRWResActor_OnRep_CurrentResObjState_Params params;
	params.LastState = LastState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOwnedCamp
// (Final, Native, Public)
// Parameters:
// int                            LastOwnedCamp                  (Parm, ZeroConstructor, IsPlainOldData)

void AExtraTeamRWResActor::OnRep_CurrentOwnedCamp(int LastOwnedCamp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOwnedCamp");

	AExtraTeamRWResActor_OnRep_CurrentOwnedCamp_Params params;
	params.LastOwnedCamp = LastOwnedCamp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOccupyProgressForRep
// (Final, Native, Public)

void AExtraTeamRWResActor::OnRep_CurrentOccupyProgressForRep()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOccupyProgressForRep");

	AExtraTeamRWResActor_OnRep_CurrentOccupyProgressForRep_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOccupyingStatus
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETRWResOccupyStatus> LastStatus                     (Parm, ZeroConstructor, IsPlainOldData)

void AExtraTeamRWResActor::OnRep_CurrentOccupyingStatus(TEnumAsByte<ETRWResOccupyStatus> LastStatus)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.OnRep_CurrentOccupyingStatus");

	AExtraTeamRWResActor_OnRep_CurrentOccupyingStatus_Params params;
	params.LastStatus = LastStatus;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetResActorDisplayName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString AExtraTeamRWResActor::GetResActorDisplayName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetResActorDisplayName");

	AExtraTeamRWResActor_GetResActorDisplayName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetPlayerListInAreaNum
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AExtraTeamRWResActor::GetPlayerListInAreaNum()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetPlayerListInAreaNum");

	AExtraTeamRWResActor_GetPlayerListInAreaNum_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetLocalPlayerPawn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APawn* AExtraTeamRWResActor::GetLocalPlayerPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetLocalPlayerPawn");

	AExtraTeamRWResActor_GetLocalPlayerPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetLocalPlayerCampID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AExtraTeamRWResActor::GetLocalPlayerCampID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetLocalPlayerCampID");

	AExtraTeamRWResActor_GetLocalPlayerCampID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurResObjState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ETRWResObjectState> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ETRWResObjectState> AExtraTeamRWResActor::GetCurResObjState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurResObjState");

	AExtraTeamRWResActor_GetCurResObjState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurrentOccupyProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AExtraTeamRWResActor::GetCurrentOccupyProgress()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurrentOccupyProgress");

	AExtraTeamRWResActor_GetCurrentOccupyProgress_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurrentOccupyingStatus
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ETRWResOccupyStatus> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ETRWResOccupyStatus> AExtraTeamRWResActor::GetCurrentOccupyingStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurrentOccupyingStatus");

	AExtraTeamRWResActor_GetCurrentOccupyingStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurOwnedCompID
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AExtraTeamRWResActor::GetCurOwnedCompID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.GetCurOwnedCompID");

	AExtraTeamRWResActor_GetCurOwnedCompID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.CapsuleEndOverlap
// (Native, Protected)
// Parameters:
// class UPrimitiveComponent*     OverlappedComp                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)

void AExtraTeamRWResActor::CapsuleEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.CapsuleEndOverlap");

	AExtraTeamRWResActor_CapsuleEndOverlap_Params params;
	params.OverlappedComp = OverlappedComp;
	params.Other = Other;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ExtraTeamRWResActor.CapsuleBeginOverlap
// (Native, Protected, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     OverlappedComp                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AExtraTeamRWResActor::CapsuleBeginOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ExtraTeamRWResActor.CapsuleBeginOverlap");

	AExtraTeamRWResActor_CapsuleBeginOverlap_Params params;
	params.OverlappedComp = OverlappedComp;
	params.Other = Other;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimulateSyncSmoothActor.SetVelocity
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Velocity                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASimulateSyncSmoothActor::SetVelocity(const struct FVector& Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimulateSyncSmoothActor.SetVelocity");

	ASimulateSyncSmoothActor_SetVelocity_Params params;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimulateSyncSmoothActor.SetAngularVelocity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          PitchSpeed                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          YawSpeed                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          RollSpeed                      (Parm, ZeroConstructor, IsPlainOldData)

void ASimulateSyncSmoothActor::SetAngularVelocity(float PitchSpeed, float YawSpeed, float RollSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimulateSyncSmoothActor.SetAngularVelocity");

	ASimulateSyncSmoothActor_SetAngularVelocity_Params params;
	params.PitchSpeed = PitchSpeed;
	params.YawSpeed = YawSpeed;
	params.RollSpeed = RollSpeed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimulateSyncSmoothActor.OnRep_Snapshot
// (Final, Native, Public)

void ASimulateSyncSmoothActor::OnRep_Snapshot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimulateSyncSmoothActor.OnRep_Snapshot");

	ASimulateSyncSmoothActor_OnRep_Snapshot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.UnRegSingleBox
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    InStatic                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AFerrisWheel::UnRegSingleBox(class UStaticMeshComponent* InStatic)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.UnRegSingleBox");

	AFerrisWheel_UnRegSingleBox_Params params;
	params.InStatic = InStatic;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.StandBox
// (Final, Native, Public, BlueprintCallable)

void AFerrisWheel::StandBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.StandBox");

	AFerrisWheel_StandBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.RegNewBox
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*  InSkel                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AFerrisWheel::RegNewBox(class USkeletalMeshComponent* InSkel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.RegNewBox");

	AFerrisWheel_RegNewBox_Params params;
	params.InSkel = InSkel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.PullBoxStand
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class USceneComponent*         InComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AFerrisWheel::PullBoxStand(class USceneComponent* InComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.PullBoxStand");

	AFerrisWheel_PullBoxStand_Params params;
	params.InComp = InComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.PassThroughDoor
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    InComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 InStart                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 InEnd                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AFerrisWheel::PassThroughDoor(class UStaticMeshComponent* InComp, const struct FVector& InStart, const struct FVector& InEnd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.PassThroughDoor");

	AFerrisWheel_PassThroughDoor_Params params;
	params.InComp = InComp;
	params.InStart = InStart;
	params.InEnd = InEnd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.FerrisWheel.OnBoxHitted
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     HitComponent                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AFerrisWheel::OnBoxHitted(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.OnBoxHitted");

	AFerrisWheel_OnBoxHitted_Params params;
	params.HitComponent = HitComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.IsInFerrisDoor
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    InComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 InPos                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           InShouldLog                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AFerrisWheel::IsInFerrisDoor(class UStaticMeshComponent* InComp, const struct FVector& InPos, bool InShouldLog)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.IsInFerrisDoor");

	AFerrisWheel_IsInFerrisDoor_Params params;
	params.InComp = InComp;
	params.InPos = InPos;
	params.InShouldLog = InShouldLog;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.FerrisWheel.IsInFerrisBox
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    InComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 InPos                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           InShouldLog                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AFerrisWheel::IsInFerrisBox(class UStaticMeshComponent* InComp, const struct FVector& InPos, bool InShouldLog)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.IsInFerrisBox");

	AFerrisWheel_IsInFerrisBox_Params params;
	params.InComp = InComp;
	params.InPos = InPos;
	params.InShouldLog = InShouldLog;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.FerrisWheel.Init_Refs
// (Event, Public, BlueprintEvent)

void AFerrisWheel::Init_Refs()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.Init_Refs");

	AFerrisWheel_Init_Refs_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.GetGoodOutPos
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    InComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 InPos                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           ForceForward                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector AFerrisWheel::GetGoodOutPos(class UStaticMeshComponent* InComp, const struct FVector& InPos, bool ForceForward)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.GetGoodOutPos");

	AFerrisWheel_GetGoodOutPos_Params params;
	params.InComp = InComp;
	params.InPos = InPos;
	params.ForceForward = ForceForward;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.FerrisWheel.CheckPosition
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InPos                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class UStaticMeshComponent*    InHitedBox                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AFerrisWheel::CheckPosition(const struct FVector& InPos, class UStaticMeshComponent* InHitedBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.CheckPosition");

	AFerrisWheel_CheckPosition_Params params;
	params.InPos = InPos;
	params.InHitedBox = InHitedBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FerrisWheel.BroadcastEnableTick
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// bool                           bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)

void AFerrisWheel::BroadcastEnableTick(bool bEnabled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FerrisWheel.BroadcastEnableTick");

	AFerrisWheel_BroadcastEnableTick_Params params;
	params.bEnabled = bEnabled;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SpecialBulletBase.RPC_Multicast_StartLaunch
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 Velocity                       (Parm, IsPlainOldData)
// float                          Gravity                        (Parm, ZeroConstructor, IsPlainOldData)

void ASpecialBulletBase::RPC_Multicast_StartLaunch(const struct FVector& Velocity, float Gravity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SpecialBulletBase.RPC_Multicast_StartLaunch");

	ASpecialBulletBase_RPC_Multicast_StartLaunch_Params params;
	params.Velocity = Velocity;
	params.Gravity = Gravity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.SpecialBulletBase.LaunchBulletDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASpecialBulletBase::LaunchBulletDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.SpecialBulletBase.LaunchBulletDelegate__DelegateSignature");

	ASpecialBulletBase_LaunchBulletDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FireworkBullet.RPC_Multicast_Explode
// (Net, NetReliable, Native, Event, NetMulticast, Protected, NetValidate)

void AFireworkBullet::RPC_Multicast_Explode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FireworkBullet.RPC_Multicast_Explode");

	AFireworkBullet_RPC_Multicast_Explode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FireworkBullet.OnExplode
// (Event, Public, BlueprintEvent)

void AFireworkBullet::OnExplode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FireworkBullet.OnExplode");

	AFireworkBullet_OnExplode_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FireworkBullet.OnBounce
// (Native, Protected, HasOutParms, HasDefaults)
// Parameters:
// struct FHitResult              _ImpactResult                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 _ImpactVelocity                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AFireworkBullet::OnBounce(const struct FHitResult& _ImpactResult, const struct FVector& _ImpactVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FireworkBullet.OnBounce");

	AFireworkBullet_OnBounce_Params params;
	params._ImpactResult = _ImpactResult;
	params._ImpactVelocity = _ImpactVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.FPPSpringArmComponent.SetFPPCameraDataEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EFPPCameraDataType> CameraDataType                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void UFPPSpringArmComponent::SetFPPCameraDataEnable(TEnumAsByte<EFPPCameraDataType> CameraDataType, bool IsEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.FPPSpringArmComponent.SetFPPCameraDataEnable");

	UFPPSpringArmComponent_SetFPPCameraDataEnable_Params params;
	params.CameraDataType = CameraDataType;
	params.IsEnable = IsEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.StarCalcJump
// (Final, Native, Public)

void UGameEventListener::StarCalcJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.StarCalcJump");

	UGameEventListener_StarCalcJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.ScaleScreenSizeCulling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EGamePawnEvent>    pawnevent                      (Parm, ZeroConstructor, IsPlainOldData)

void UGameEventListener::ScaleScreenSizeCulling(TEnumAsByte<EGamePawnEvent> pawnevent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.ScaleScreenSizeCulling");

	UGameEventListener_ScaleScreenSizeCulling_Params params;
	params.pawnevent = pawnevent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.OnChangeViewTarget
// (Final, Native, Public)

void UGameEventListener::OnChangeViewTarget()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.OnChangeViewTarget");

	UGameEventListener_OnChangeViewTarget_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.IsPlayerLandFromTheAir
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameEventListener::IsPlayerLandFromTheAir()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.IsPlayerLandFromTheAir");

	UGameEventListener_IsPlayerLandFromTheAir_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameEventListener.IsPlayerLanded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameEventListener::IsPlayerLanded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.IsPlayerLanded");

	UGameEventListener_IsPlayerLanded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameEventListener.IsPlayerFlying
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGameEventListener::IsPlayerFlying()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.IsPlayerFlying");

	UGameEventListener_IsPlayerFlying_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GameEventListener.HeightCheck
// (Final, Native, Public)

void UGameEventListener::HeightCheck()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.HeightCheck");

	UGameEventListener_HeightCheck_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventReBirth
// (Final, Native, Public)

void UGameEventListener::GameEventReBirth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventReBirth");

	UGameEventListener_GameEventReBirth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventPlane
// (Final, Native, Public)

void UGameEventListener::GameEventPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventPlane");

	UGameEventListener_GameEventPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventParachute
// (Final, Native, Public)

void UGameEventListener::GameEventParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventParachute");

	UGameEventListener_GameEventParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventLanded
// (Final, Native, Public)

void UGameEventListener::GameEventLanded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventLanded");

	UGameEventListener_GameEventLanded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventJump
// (Final, Native, Public)

void UGameEventListener::GameEventJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventJump");

	UGameEventListener_GameEventJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventFighting
// (Final, Native, Public)

void UGameEventListener::GameEventFighting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventFighting");

	UGameEventListener_GameEventFighting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventDie
// (Final, Native, Public)
// Parameters:
// float                          currentHP                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ratioHP                        (Parm, ZeroConstructor, IsPlainOldData)

void UGameEventListener::GameEventDie(float currentHP, float ratioHP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventDie");

	UGameEventListener_GameEventDie_Params params;
	params.currentHP = currentHP;
	params.ratioHP = ratioHP;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.GameEventBirth
// (Final, Native, Public)

void UGameEventListener::GameEventBirth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.GameEventBirth");

	UGameEventListener_GameEventBirth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameEventListener.ChangeViewtargetToPlane
// (Final, Native, Public)

void UGameEventListener::ChangeViewtargetToPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameEventListener.ChangeViewtargetToPlane");

	UGameEventListener_ChangeViewtargetToPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameModeState_Training.BroadcastAboutToOver
// (Final, Native, Protected)

void UGameModeState_Training::BroadcastAboutToOver()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameModeState_Training.BroadcastAboutToOver");

	UGameModeState_Training_BroadcastAboutToOver_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GameModeStateReady.StopJoin
// (Final, Native, Public)

void UGameModeStateReady::StopJoin()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GameModeStateReady.StopJoin");

	UGameModeStateReady_StopJoin_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.VisualizeItem
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::VisualizeItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.VisualizeItem");

	ASTExtraPlayerController_VisualizeItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ViewVehicle
// (Final, Native, Public, HasDefaults)
// Parameters:
// float                          YawAdd                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          PitchAdd                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::ViewVehicle(float YawAdd, float PitchAdd, const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ViewVehicle");

	ASTExtraPlayerController_ViewVehicle_Params params;
	params.YawAdd = YawAdd;
	params.PitchAdd = PitchAdd;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ViewPlane
// (Final, Native, Public)

void ASTExtraPlayerController::ViewPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ViewPlane");

	ASTExtraPlayerController_ViewPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.UserDropItemOperation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)

void ASTExtraPlayerController::UserDropItemOperation(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.UserDropItemOperation");

	ASTExtraPlayerController_UserDropItemOperation_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.UseItem
// (Final, Exec, Native, Public)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::UseItem(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.UseItem");

	ASTExtraPlayerController_UseItem_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.UpdatePoseState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEPoseState>     PoseType                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::UpdatePoseState(TEnumAsByte<ESTEPoseState> PoseType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.UpdatePoseState");

	ASTExtraPlayerController_UpdatePoseState_Params params;
	params.PoseType = PoseType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.UnLoadAllCollision
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Unload                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::UnLoadAllCollision(bool Unload)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.UnLoadAllCollision");

	ASTExtraPlayerController_UnLoadAllCollision_Params params;
	params.Unload = Unload;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.TouchMove
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::TouchMove(const struct FVector& Loc, TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.TouchMove");

	ASTExtraPlayerController_TouchMove_Params params;
	params.Loc = Loc;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.TouchEnd
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPressType>        PressType                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::TouchEnd(TEnumAsByte<EPressType> PressType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.TouchEnd");

	ASTExtraPlayerController_TouchEnd_Params params;
	params.PressType = PressType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.TouchBegin
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPressType>        PressType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::TouchBegin(TEnumAsByte<EPressType> PressType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.TouchBegin");

	ASTExtraPlayerController_TouchBegin_Params params;
	params.PressType = PressType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleVehicleSync
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleVehicleSync(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleVehicleSync");

	ASTExtraPlayerController_ToggleVehicleSync_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaSendAck
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleUserCmdDeltaSendAck(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaSendAck");

	ASTExtraPlayerController_ToggleUserCmdDeltaSendAck_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaFlag
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleUserCmdDeltaFlag(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaFlag");

	ASTExtraPlayerController_ToggleUserCmdDeltaFlag_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaCheckSum
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleUserCmdDeltaCheckSum(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDeltaCheckSum");

	ASTExtraPlayerController_ToggleUserCmdDeltaCheckSum_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDelta
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleUserCmdDelta(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleUserCmdDelta");

	ASTExtraPlayerController_ToggleUserCmdDelta_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleServerAcknowledgePossession
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleServerAcknowledgePossession(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleServerAcknowledgePossession");

	ASTExtraPlayerController_ToggleServerAcknowledgePossession_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleEnableOBBulletTrackEffectSetting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleEnableOBBulletTrackEffectSetting(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleEnableOBBulletTrackEffectSetting");

	ASTExtraPlayerController_ToggleEnableOBBulletTrackEffectSetting_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ToggleCheatLocation
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ToggleCheatLocation(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ToggleCheatLocation");

	ASTExtraPlayerController_ToggleCheatLocation_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.TeamNoAlwaysRelevant
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::TeamNoAlwaysRelevant()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.TeamNoAlwaysRelevant");

	ASTExtraPlayerController_TeamNoAlwaysRelevant_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.TeamMateStateChanged
// (Net, Native, Event, Public, NetClient)
// Parameters:
// class ASTExtraPlayerState*     STPlayerState                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  Location                       (Parm)
// uint32_t                       View                           (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Roll                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          Health                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            VoiceID                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::TeamMateStateChanged(class ASTExtraPlayerState* STPlayerState, const struct FVector_NetQuantize100& Location, uint32_t View, unsigned char Roll, float Health, int VoiceID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.TeamMateStateChanged");

	ASTExtraPlayerController_TeamMateStateChanged_Params params;
	params.STPlayerState = STPlayerState;
	params.Location = Location;
	params.View = View;
	params.Roll = Roll;
	params.Health = Health;
	params.VoiceID = VoiceID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchViewTarget
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::SwitchViewTarget()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchViewTarget");

	ASTExtraPlayerController_SwitchViewTarget_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchToDeadBox
// (Final, Native, Public)

void ASTExtraPlayerController::SwitchToDeadBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchToDeadBox");

	ASTExtraPlayerController_SwitchToDeadBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateServer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     PoseState                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwitchPoseStateServer(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEPoseState> PoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateServer");

	ASTExtraPlayerController_SwitchPoseStateServer_Params params;
	params.TargetCharacter = TargetCharacter;
	params.PoseState = PoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateFailedResponse
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     FailedPoseState                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     CurPoseState                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwitchPoseStateFailedResponse(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEPoseState> FailedPoseState, TEnumAsByte<ESTEPoseState> CurPoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateFailedResponse");

	ASTExtraPlayerController_SwitchPoseStateFailedResponse_Params params;
	params.TargetCharacter = TargetCharacter;
	params.FailedPoseState = FailedPoseState;
	params.CurPoseState = CurPoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateClient
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     PoseState                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwitchPoseStateClient(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEPoseState> PoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchPoseStateClient");

	ASTExtraPlayerController_SwitchPoseStateClient_Params params;
	params.TargetCharacter = TargetCharacter;
	params.PoseState = PoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchGenerateItem
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void ASTExtraPlayerController::SwitchGenerateItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchGenerateItem");

	ASTExtraPlayerController_SwitchGenerateItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraModeScope
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   InCharacter                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwitchCameraModeScope(TEnumAsByte<EPlayerCameraMode> Mode, class ASTExtraBaseCharacter* InCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraModeScope");

	ASTExtraPlayerController_SwitchCameraModeScope_Params params;
	params.Mode = Mode;
	params.InCharacter = InCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraModeByOrder
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::SwitchCameraModeByOrder()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraModeByOrder");

	ASTExtraPlayerController_SwitchCameraModeByOrder_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   InCharacter                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsUseLerpFPP                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsForceSwitch                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwitchCameraMode(TEnumAsByte<EPlayerCameraMode> Mode, class ASTExtraBaseCharacter* InCharacter, bool IsUseLerpFPP, bool IsForceSwitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwitchCameraMode");

	ASTExtraPlayerController_SwitchCameraMode_Params params;
	params.Mode = Mode;
	params.InCharacter = InCharacter;
	params.IsUseLerpFPP = IsUseLerpFPP;
	params.IsForceSwitch = IsForceSwitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SwapWeaponByPropSlotOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot1                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot2                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForce                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SwapWeaponByPropSlotOnServer(TEnumAsByte<ESurviveWeaponPropSlot> Slot1, TEnumAsByte<ESurviveWeaponPropSlot> Slot2, bool bForce)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SwapWeaponByPropSlotOnServer");

	ASTExtraPlayerController_SwapWeaponByPropSlotOnServer_Params params;
	params.Slot1 = Slot1;
	params.Slot2 = Slot2;
	params.bForce = bForce;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StopAutoDoorTest
// (Final, Exec, Native, Public)
// Parameters:
// int                            ConfigGraphIndex               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StopAutoDoorTest(int ConfigGraphIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StopAutoDoorTest");

	ASTExtraPlayerController_StopAutoDoorTest_Params params;
	params.ConfigGraphIndex = ConfigGraphIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StopAI
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::StopAI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StopAI");

	ASTExtraPlayerController_StopAI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartReadyCountDown
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::StartReadyCountDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartReadyCountDown");

	ASTExtraPlayerController_StartReadyCountDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartLandOnGroundAfterJumpPlane
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::StartLandOnGroundAfterJumpPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartLandOnGroundAfterJumpPlane");

	ASTExtraPlayerController_StartLandOnGroundAfterJumpPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartGame
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::StartGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartGame");

	ASTExtraPlayerController_StartGame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartFreeCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FigerIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartFreeCamera(TEnumAsByte<ETouchIndex> FigerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartFreeCamera");

	ASTExtraPlayerController_StartFreeCamera_Params params;
	params.FigerIndex = FigerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartAutoDoorTest
// (Final, Exec, Native, Public)
// Parameters:
// int                            ConfigGraphIndex               (Parm, ZeroConstructor, IsPlainOldData)
// float                          WorldSizeX                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          WorldSizeY                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          BlockLoadTime                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          WorldLEftTopX                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          WorldLeftTopY                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          BlockSizeX                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          BlockSizeY                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartAutoDoorTest(int ConfigGraphIndex, float WorldSizeX, float WorldSizeY, float BlockLoadTime, float WorldLEftTopX, float WorldLeftTopY, float BlockSizeX, float BlockSizeY)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartAutoDoorTest");

	ASTExtraPlayerController_StartAutoDoorTest_Params params;
	params.ConfigGraphIndex = ConfigGraphIndex;
	params.WorldSizeX = WorldSizeX;
	params.WorldSizeY = WorldSizeY;
	params.BlockLoadTime = BlockLoadTime;
	params.WorldLEftTopX = WorldLEftTopX;
	params.WorldLeftTopY = WorldLeftTopY;
	params.BlockSizeX = BlockSizeX;
	params.BlockSizeY = BlockSizeY;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartAirDropSpecified
// (Final, Exec, Native, Public)
// Parameters:
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartAirDropSpecified(float X, float Y)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartAirDropSpecified");

	ASTExtraPlayerController_StartAirDropSpecified_Params params;
	params.X = X;
	params.Y = Y;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartAirDrop
// (Final, Exec, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartAirDrop(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartAirDrop");

	ASTExtraPlayerController_StartAirDrop_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartAirAttackSpecified
// (Final, Exec, Native, Public)
// Parameters:
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartAirAttackSpecified(float X, float Y, float Radius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartAirAttackSpecified");

	ASTExtraPlayerController_StartAirAttackSpecified_Params params;
	params.X = X;
	params.Y = Y;
	params.Radius = Radius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.StartAirAttack
// (Final, Exec, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::StartAirAttack(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.StartAirAttack");

	ASTExtraPlayerController_StartAirAttack_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SpectatorCameraChange_Broadcast
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// bool                           bDie                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SpectatorCameraChange_Broadcast(bool bDie)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SpectatorCameraChange_Broadcast");

	ASTExtraPlayerController_SpectatorCameraChange_Broadcast_Params params;
	params.bDie = bDie;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SpawnVehicleWithPath
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 Path                           (Parm, ZeroConstructor)

void ASTExtraPlayerController::SpawnVehicleWithPath(const struct FString& Path)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SpawnVehicleWithPath");

	ASTExtraPlayerController_SpawnVehicleWithPath_Params params;
	params.Path = Path;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SpawnVehicle
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::SpawnVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SpawnVehicle");

	ASTExtraPlayerController_SpawnVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SpawnAITeammate
// (Final, Exec, Native, Public)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SpawnAITeammate(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SpawnAITeammate");

	ASTExtraPlayerController_SpawnAITeammate_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SpawnAI
// (Final, Exec, Native, Public)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SpawnAI(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SpawnAI");

	ASTExtraPlayerController_SpawnAI_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SoftReconnectRecoverData
// (Final, Native, Public)
// Parameters:
// class AUAEPlayerController*    PC                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SoftReconnectRecoverData(class AUAEPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SoftReconnectRecoverData");

	ASTExtraPlayerController_SoftReconnectRecoverData_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowVaultEnable
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::ShowVaultEnable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowVaultEnable");

	ASTExtraPlayerController_ShowVaultEnable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowPoints
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// TArray<struct FVector>         Points                         (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// struct FColor                  Color                          (ConstParm, Parm, IsPlainOldData)
// float                          LifeTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ShowPoints(TArray<struct FVector> Points, const struct FColor& Color, float LifeTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowPoints");

	ASTExtraPlayerController_ShowPoints_Params params;
	params.Points = Points;
	params.Color = Color;
	params.LifeTime = LifeTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowMovePath
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// TArray<struct FVector>         Path                           (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::ShowMovePath(TArray<struct FVector> Path)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowMovePath");

	ASTExtraPlayerController_ShowMovePath_Params params;
	params.Path = Path;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowFireBtn
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ShowFireBtn(bool bShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowFireBtn");

	ASTExtraPlayerController_ShowFireBtn_Params params;
	params.bShow = bShow;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowBulletShoot
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 StartLoc                       (Parm, IsPlainOldData)
// struct FRotator                Rot                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::ShowBulletShoot(const struct FVector& StartLoc, const struct FRotator& Rot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowBulletShoot");

	ASTExtraPlayerController_ShowBulletShoot_Params params;
	params.StartLoc = StartLoc;
	params.Rot = Rot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShowAllRoles
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::ShowAllRoles()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShowAllRoles");

	ASTExtraPlayerController_ShowAllRoles_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShouldForceFPPView
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerCharacter* InCharacter                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::ShouldForceFPPView(class ASTExtraPlayerCharacter* InCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShouldForceFPPView");

	ASTExtraPlayerController_ShouldForceFPPView_Params params;
	params.InCharacter = InCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ShouldDisplayInGameUI
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::ShouldDisplayInGameUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ShouldDisplayInGameUI");

	ASTExtraPlayerController_ShouldDisplayInGameUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetVirtualStickVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bJSVisiable                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetVirtualStickVisibility(bool bJSVisiable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetVirtualStickVisibility");

	ASTExtraPlayerController_SetVirtualStickVisibility_Params params;
	params.bJSVisiable = bJSVisiable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetVirtualStickAutoSprintStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bVirtualstickAutoSprint        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bUIOnly                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetVirtualStickAutoSprintStatus(bool bVirtualstickAutoSprint, bool bUIOnly)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetVirtualStickAutoSprintStatus");

	ASTExtraPlayerController_SetVirtualStickAutoSprintStatus_Params params;
	params.bVirtualstickAutoSprint = bVirtualstickAutoSprint;
	params.bUIOnly = bUIOnly;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SettingFromConfigFile
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::SettingFromConfigFile()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SettingFromConfigFile");

	ASTExtraPlayerController_SettingFromConfigFile_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetTimeSpeedFactor
// (Final, Exec, Native, Public)
// Parameters:
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetTimeSpeedFactor(float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetTimeSpeedFactor");

	ASTExtraPlayerController_SetTimeSpeedFactor_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetTimeSpeedCheck
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetTimeSpeedCheck(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetTimeSpeedCheck");

	ASTExtraPlayerController_SetTimeSpeedCheck_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetStateLeftTime
// (Final, Exec, Native, Public)
// Parameters:
// int                            LeftTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetStateLeftTime(int LeftTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetStateLeftTime");

	ASTExtraPlayerController_SetStateLeftTime_Params params;
	params.LeftTime = LeftTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetSpeed
// (Final, Exec, Native, Public)
// Parameters:
// float                          Modifier                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetSpeed(float Modifier)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetSpeed");

	ASTExtraPlayerController_SetSpeed_Params params;
	params.Modifier = Modifier;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetServerLevelLoadingMode
// (Final, Exec, Native, Public)
// Parameters:
// bool                           bNewLoadAll                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetServerLevelLoadingMode(bool bNewLoadAll)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetServerLevelLoadingMode");

	ASTExtraPlayerController_SetServerLevelLoadingMode_Params params;
	params.bNewLoadAll = bNewLoadAll;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetScopeFingerIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           TouchBegin                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetScopeFingerIndex(bool TouchBegin, TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetScopeFingerIndex");

	ASTExtraPlayerController_SetScopeFingerIndex_Params params;
	params.TouchBegin = TouchBegin;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetPlayerMark
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, BlueprintCallable, NetValidate)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::SetPlayerMark(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetPlayerMark");

	ASTExtraPlayerController_SetPlayerMark_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetPlaneEnabled
// (Final, Exec, Native, Public)
// Parameters:
// bool                           InEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetPlaneEnabled(bool InEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetPlaneEnabled");

	ASTExtraPlayerController_SetPlaneEnabled_Params params;
	params.InEnable = InEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetPeekFingerIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           TouchBegin                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           AutoCancelPeek                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetPeekFingerIndex(bool TouchBegin, TEnumAsByte<ETouchIndex> FingerIndex, bool AutoCancelPeek)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetPeekFingerIndex");

	ASTExtraPlayerController_SetPeekFingerIndex_Params params;
	params.TouchBegin = TouchBegin;
	params.FingerIndex = FingerIndex;
	params.AutoCancelPeek = AutoCancelPeek;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetMaxHealth
// (Final, Exec, Native, Public)
// Parameters:
// float                          HP                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetMaxHealth(float HP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetMaxHealth");

	ASTExtraPlayerController_SetMaxHealth_Params params;
	params.HP = HP;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          JSScale                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetJoyStickScale(float JSScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickScale");

	ASTExtraPlayerController_SetJoyStickScale_Params params;
	params.JSScale = JSScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoystickOperatingMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EJoystickOperatingMode> OperatingMode                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          GoStraightAngle                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetJoystickOperatingMode(TEnumAsByte<EJoystickOperatingMode> OperatingMode, float GoStraightAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoystickOperatingMode");

	ASTExtraPlayerController_SetJoystickOperatingMode_Params params;
	params.OperatingMode = OperatingMode;
	params.GoStraightAngle = GoStraightAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickOpacity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          JSOpacity                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetJoyStickOpacity(float JSOpacity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickOpacity");

	ASTExtraPlayerController_SetJoyStickOpacity_Params params;
	params.JSOpacity = JSOpacity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickInteractionSize
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               JSInteractionSize              (Parm, IsPlainOldData)

void ASTExtraPlayerController::SetJoyStickInteractionSize(const struct FVector2D& JSInteractionSize)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickInteractionSize");

	ASTExtraPlayerController_SetJoyStickInteractionSize_Params params;
	params.JSInteractionSize = JSInteractionSize;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoystickFireModeIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            _index                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetJoystickFireModeIndex(int _index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoystickFireModeIndex");

	ASTExtraPlayerController_SetJoystickFireModeIndex_Params params;
	params._index = _index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickCenter
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               JSCenter                       (Parm, IsPlainOldData)

void ASTExtraPlayerController::SetJoyStickCenter(const struct FVector2D& JSCenter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetJoyStickCenter");

	ASTExtraPlayerController_SetJoyStickCenter_Params params;
	params.JSCenter = JSCenter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetIsSnowy
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bSnowy                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetIsSnowy(bool bSnowy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetIsSnowy");

	ASTExtraPlayerController_SetIsSnowy_Params params;
	params.bSnowy = bSnowy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetIsRainy
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bRainy                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetIsRainy(bool bRainy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetIsRainy");

	ASTExtraPlayerController_SetIsRainy_Params params;
	params.bRainy = bRainy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetIsCanRegion
// (Final, Exec, Native, Public)
// Parameters:
// bool                           CanRegion                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetIsCanRegion(bool CanRegion)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetIsCanRegion");

	ASTExtraPlayerController_SetIsCanRegion_Params params;
	params.CanRegion = CanRegion;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetIsBlizzard
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bBlizzard                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetIsBlizzard(bool bBlizzard)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetIsBlizzard");

	ASTExtraPlayerController_SetIsBlizzard_Params params;
	params.bBlizzard = bBlizzard;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetGameStateReconnectInfoToClient
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FReConnectGameStateInfo ReConnectInfo                  (Parm)

void ASTExtraPlayerController::SetGameStateReconnectInfoToClient(const struct FReConnectGameStateInfo& ReConnectInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetGameStateReconnectInfoToClient");

	ASTExtraPlayerController_SetGameStateReconnectInfoToClient_Params params;
	params.ReConnectInfo = ReConnectInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetGameStateModeUI
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// TArray<struct FString>         ModeUIMgr                      (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::SetGameStateModeUI(TArray<struct FString> ModeUIMgr)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetGameStateModeUI");

	ASTExtraPlayerController_SetGameStateModeUI_Params params;
	params.ModeUIMgr = ModeUIMgr;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetEnableVoiceByPlayerKey
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerState*     State                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetEnableVoiceByPlayerKey(class ASTExtraPlayerState* State, bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetEnableVoiceByPlayerKey");

	ASTExtraPlayerController_SetEnableVoiceByPlayerKey_Params params;
	params.State = State;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetDriverSettingIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            _index                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetDriverSettingIndex(int _index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetDriverSettingIndex");

	ASTExtraPlayerController_SetDriverSettingIndex_Params params;
	params._index = _index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetDriverMode3_Switcher
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           isCheck                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetDriverMode3_Switcher(bool isCheck)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetDriverMode3_Switcher");

	ASTExtraPlayerController_SetDriverMode3_Switcher_Params params;
	params.isCheck = isCheck;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetCustomFlightRoute
// (Final, Exec, Native, Public)
// Parameters:
// float                          StartX                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          StartY                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          EndX                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          EndY                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetCustomFlightRoute(float StartX, float StartY, float EndX, float EndY)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetCustomFlightRoute");

	ASTExtraPlayerController_SetCustomFlightRoute_Params params;
	params.StartX = StartX;
	params.StartY = StartY;
	params.EndX = EndX;
	params.EndY = EndY;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetCurrentCameraFOV
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// float                          FOV                            (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetCurrentCameraFOV(float FOV, TEnumAsByte<EPlayerCameraMode> Mode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetCurrentCameraFOV");

	ASTExtraPlayerController_SetCurrentCameraFOV_Params params;
	params.FOV = FOV;
	params.Mode = Mode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetControlRotation
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                NewRotation                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::SetControlRotation(const struct FRotator& NewRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetControlRotation");

	ASTExtraPlayerController_SetControlRotation_Params params;
	params.NewRotation = NewRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetClientSpawnAndBackpackWeaponReplicatedDataArray
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// TArray<struct FItemDefineID>   DataList                       (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::SetClientSpawnAndBackpackWeaponReplicatedDataArray(TArray<struct FItemDefineID> DataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetClientSpawnAndBackpackWeaponReplicatedDataArray");

	ASTExtraPlayerController_SetClientSpawnAndBackpackWeaponReplicatedDataArray_Params params;
	params.DataList = DataList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetCirCenterFixed
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetCirCenterFixed(bool Enable, float X, float Y)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetCirCenterFixed");

	ASTExtraPlayerController_SetCirCenterFixed_Params params;
	params.Enable = Enable;
	params.X = X;
	params.Y = Y;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetAirDropEnable
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetAirDropEnable(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetAirDropEnable");

	ASTExtraPlayerController_SetAirDropEnable_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SetAirAttackEnable
// (Final, Exec, Native, Public)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SetAirAttackEnable(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SetAirAttackEnable");

	ASTExtraPlayerController_SetAirAttackEnable_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerUseItem
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FBattleItemUseTarget    Target                         (Parm)
// EBattleItemUseReason           Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerUseItem(const struct FItemDefineID& DefineID, const struct FBattleItemUseTarget& Target, EBattleItemUseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerUseItem");

	ASTExtraPlayerController_ServerUseItem_Params params;
	params.DefineID = DefineID;
	params.Target = Target;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerSelectGrenade
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// int                            GrenadeID                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerTriggerSelectGrenade(int GrenadeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerSelectGrenade");

	ASTExtraPlayerController_ServerTriggerSelectGrenade_Params params;
	params.GrenadeID = GrenadeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerCharacterEntryEvent
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EUTSkillEntry                  EntryEvent                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerTriggerCharacterEntryEvent(EUTSkillEntry EntryEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerCharacterEntryEvent");

	ASTExtraPlayerController_ServerTriggerCharacterEntryEvent_Params params;
	params.EntryEvent = EntryEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerCharacterCustomEvent
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<EUAESkillEvent>    SkillEvent                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerTriggerCharacterCustomEvent(TEnumAsByte<EUAESkillEvent> SkillEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerTriggerCharacterCustomEvent");

	ASTExtraPlayerController_ServerTriggerCharacterCustomEvent_Params params;
	params.SkillEvent = SkillEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerStopFire
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraShootWeapon*     TargetWeapon                   (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       CurClipID                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurrentBullet                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerStopFire(class ASTExtraBaseCharacter* TargetCharacter, class ASTExtraShootWeapon* TargetWeapon, uint32_t CurClipID, int CurrentBullet)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerStopFire");

	ASTExtraPlayerController_ServerStopFire_Params params;
	params.TargetCharacter = TargetCharacter;
	params.TargetWeapon = TargetWeapon;
	params.CurClipID = CurClipID;
	params.CurrentBullet = CurrentBullet;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerStartPreBarrel
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// float                          HandledTime                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerStartPreBarrel(class ASTExtraBaseCharacter* TargetCharacter, float HandledTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerStartPreBarrel");

	ASTExtraPlayerController_ServerStartPreBarrel_Params params;
	params.TargetCharacter = TargetCharacter;
	params.HandledTime = HandledTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerStartOnPlaneSurvive
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// float                          P_PlaneFlyHeight               (Parm, ZeroConstructor, IsPlainOldData)
// float                          P_PlaneStartDistance           (Parm, ZeroConstructor, IsPlainOldData)
// float                          P_PlaneFlySpeed                (Parm, ZeroConstructor, IsPlainOldData)
// float                          P_HaveToJumpDistance           (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 P_MapCenterLoc                 (Parm, IsPlainOldData)
// struct FVector                 P_PlaneStartLoc                (Parm, IsPlainOldData)
// float                          P_PlaneStartYaw                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerStartOnPlaneSurvive(float P_PlaneFlyHeight, float P_PlaneStartDistance, float P_PlaneFlySpeed, float P_HaveToJumpDistance, const struct FVector& P_MapCenterLoc, const struct FVector& P_PlaneStartLoc, float P_PlaneStartYaw)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerStartOnPlaneSurvive");

	ASTExtraPlayerController_ServerStartOnPlaneSurvive_Params params;
	params.P_PlaneFlyHeight = P_PlaneFlyHeight;
	params.P_PlaneStartDistance = P_PlaneStartDistance;
	params.P_PlaneFlySpeed = P_PlaneFlySpeed;
	params.P_HaveToJumpDistance = P_HaveToJumpDistance;
	params.P_MapCenterLoc = P_MapCenterLoc;
	params.P_PlaneStartLoc = P_PlaneStartLoc;
	params.P_PlaneStartYaw = P_PlaneStartYaw;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerStartFire
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraShootWeapon*     TargetWeapon                   (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       CurShootID                     (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       CurClipID                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurBulletNumInClip             (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EShootWeaponShootMode> ShootMode                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerStartFire(class ASTExtraBaseCharacter* TargetCharacter, class ASTExtraShootWeapon* TargetWeapon, uint32_t CurShootID, uint32_t CurClipID, int CurBulletNumInClip, TEnumAsByte<EShootWeaponShootMode> ShootMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerStartFire");

	ASTExtraPlayerController_ServerStartFire_Params params;
	params.TargetCharacter = TargetCharacter;
	params.TargetWeapon = TargetWeapon;
	params.CurShootID = CurShootID;
	params.CurClipID = CurClipID;
	params.CurBulletNumInClip = CurBulletNumInClip;
	params.ShootMode = ShootMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerStartBarrel
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerStartBarrel(class ASTExtraBaseCharacter* TargetCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerStartBarrel");

	ASTExtraPlayerController_ServerStartBarrel_Params params;
	params.TargetCharacter = TargetCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetShootType
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEWeaponShootType> shootType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerSetShootType(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEWeaponShootType> shootType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetShootType");

	ASTExtraPlayerController_ServerSetShootType_Params params;
	params.TargetCharacter = TargetCharacter;
	params.shootType = shootType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetReloadMethod
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EWeaponReloadMethod> reloadMethod                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerSetReloadMethod(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<EWeaponReloadMethod> reloadMethod)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetReloadMethod");

	ASTExtraPlayerController_ServerSetReloadMethod_Params params;
	params.TargetCharacter = TargetCharacter;
	params.reloadMethod = reloadMethod;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetObsverLocation
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 locat                          (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::ServerSetObsverLocation(const struct FVector& locat)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetObsverLocation");

	ASTExtraPlayerController_ServerSetObsverLocation_Params params;
	params.locat = locat;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetIsFreeView
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           isFreeView                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerSetIsFreeView(bool isFreeView)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetIsFreeView");

	ASTExtraPlayerController_ServerSetIsFreeView_Params params;
	params.isFreeView = isFreeView;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetFreeCameraRotationOnVehicle
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FRotator                InRotation                     (Parm, IsPlainOldData)
// bool                           IsAutoReturn                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerSetFreeCameraRotationOnVehicle(const struct FRotator& InRotation, bool IsAutoReturn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetFreeCameraRotationOnVehicle");

	ASTExtraPlayerController_ServerSetFreeCameraRotationOnVehicle_Params params;
	params.InRotation = InRotation;
	params.IsAutoReturn = IsAutoReturn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetFreeCamera
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FRotator                InRotation                     (Parm, IsPlainOldData)

void ASTExtraPlayerController::ServerSetFreeCamera(const struct FRotator& InRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetFreeCamera");

	ASTExtraPlayerController_ServerSetFreeCamera_Params params;
	params.InRotation = InRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetControlRotationOnVehicle
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FRotator                InRotation                     (Parm, IsPlainOldData)

void ASTExtraPlayerController::ServerSetControlRotationOnVehicle(const struct FRotator& InRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetControlRotationOnVehicle");

	ASTExtraPlayerController_ServerSetControlRotationOnVehicle_Params params;
	params.InRotation = InRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerSetControlRotation
// (Net, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FRotator                NewRotation                    (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::ServerSetControlRotation(const struct FRotator& NewRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerSetControlRotation");

	ASTExtraPlayerController_ServerSetControlRotation_Params params;
	params.NewRotation = NewRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerReportWatchGamePlayerInfoButtonClick
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FWatchGamePlayerInfoButtonClick PlayerInfoButtonClick          (Parm)

void ASTExtraPlayerController::ServerReportWatchGamePlayerInfoButtonClick(const struct FWatchGamePlayerInfoButtonClick& PlayerInfoButtonClick)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerReportWatchGamePlayerInfoButtonClick");

	ASTExtraPlayerController_ServerReportWatchGamePlayerInfoButtonClick_Params params;
	params.PlayerInfoButtonClick = PlayerInfoButtonClick;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerReplicateExplosionEffect
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// class UClass*                  Template                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FTransform              Trans                          (Parm, IsPlainOldData)
// class AActor*                  ActorOwner                     (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   InstigatorPawn                 (Parm, ZeroConstructor, IsPlainOldData)
// ESpawnActorCollisionHandlingMethod method                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerReplicateExplosionEffect(class UClass* Template, const struct FTransform& Trans, class AActor* ActorOwner, class APawn* InstigatorPawn, ESpawnActorCollisionHandlingMethod method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerReplicateExplosionEffect");

	ASTExtraPlayerController_ServerReplicateExplosionEffect_Params params;
	params.Template = Template;
	params.Trans = Trans;
	params.ActorOwner = ActorOwner;
	params.InstigatorPawn = InstigatorPawn;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerReceiveThePlane
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int64_t                        TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerReceiveThePlane(int64_t TimeStamp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerReceiveThePlane");

	ASTExtraPlayerController_ServerReceiveThePlane_Params params;
	params.TimeStamp = TimeStamp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerReceiveServerStateType
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EStateType                     ReceivedType                   (Parm, ZeroConstructor, IsPlainOldData)
// EStateType                     ClientType                     (Parm, ZeroConstructor, IsPlainOldData)
// int64_t                        TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerReceiveServerStateType(EStateType ReceivedType, EStateType ClientType, int64_t TimeStamp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerReceiveServerStateType");

	ASTExtraPlayerController_ServerReceiveServerStateType_Params params;
	params.ReceivedType = ReceivedType;
	params.ClientType = ClientType;
	params.TimeStamp = TimeStamp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerOpenParachute
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerOpenParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerOpenParachute");

	ASTExtraPlayerController_ServerOpenParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveKiller
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerObserveKiller()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveKiller");

	ASTExtraPlayerController_ServerObserveKiller_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveCharacter
// (Final, Net, NetReliable, Native, Event, Private, NetServer, NetValidate)
// Parameters:
// uint32_t                       InPlayerKey                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerObserveCharacter(uint32_t InPlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveCharacter");

	ASTExtraPlayerController_ServerObserveCharacter_Params params;
	params.InPlayerKey = InPlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveAirDropBox
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            boxId                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerObserveAirDropBox(int boxId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerObserveAirDropBox");

	ASTExtraPlayerController_ServerObserveAirDropBox_Params params;
	params.boxId = boxId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerNotifyAutoFollowStatus
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           IsStartFollow                  (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   Target                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerNotifyAutoFollowStatus(bool IsStartFollow, class ASTExtraBaseCharacter* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerNotifyAutoFollowStatus");

	ASTExtraPlayerController_ServerNotifyAutoFollowStatus_Params params;
	params.IsStartFollow = IsStartFollow;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerJumpFromPlane
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerJumpFromPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerJumpFromPlane");

	ASTExtraPlayerController_ServerJumpFromPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerHearSound
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// int                            AkEventID                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 AkLocation                     (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::ServerHearSound(int AkEventID, const struct FVector& AkLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerHearSound");

	ASTExtraPlayerController_ServerHearSound_Params params;
	params.AkEventID = AkEventID;
	params.AkLocation = AkLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerHandleMsg
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EMsgType                       Msg                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerHandleMsg(EMsgType Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerHandleMsg");

	ASTExtraPlayerController_ServerHandleMsg_Params params;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerHandleHitDataArray
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraShootWeapon*     TargetWeapon                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FBulletHitInfoUploadData> DataArray                      (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// int                            ShootTimes                     (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FLocalShootHitData> ShootHitData                   (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::ServerHandleHitDataArray(class ASTExtraShootWeapon* TargetWeapon, TArray<struct FBulletHitInfoUploadData> DataArray, int ShootTimes, TArray<struct FLocalShootHitData> ShootHitData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerHandleHitDataArray");

	ASTExtraPlayerController_ServerHandleHitDataArray_Params params;
	params.TargetWeapon = TargetWeapon;
	params.DataArray = DataArray;
	params.ShootTimes = ShootTimes;
	params.ShootHitData = ShootHitData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerGetTotalPlayers
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerGetTotalPlayers()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerGetTotalPlayers");

	ASTExtraPlayerController_ServerGetTotalPlayers_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerGetCurOBPlayerWeaponSkinID
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void ASTExtraPlayerController::ServerGetCurOBPlayerWeaponSkinID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerGetCurOBPlayerWeaponSkinID");

	ASTExtraPlayerController_ServerGetCurOBPlayerWeaponSkinID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerFight
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerFight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerFight");

	ASTExtraPlayerController_ServerFight_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerExitFreeCamera
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerExitFreeCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerExitFreeCamera");

	ASTExtraPlayerController_ServerExitFreeCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerDropItem
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// EBattleItemDropReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerDropItem(const struct FItemDefineID& DefineID, int Count, EBattleItemDropReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerDropItem");

	ASTExtraPlayerController_ServerDropItem_Params params;
	params.DefineID = DefineID;
	params.Count = Count;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerDisuseItem
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// EBattleItemDisuseReason        Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ServerDisuseItem(const struct FItemDefineID& DefineID, EBattleItemDisuseReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerDisuseItem");

	ASTExtraPlayerController_ServerDisuseItem_Params params;
	params.DefineID = DefineID;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerCMD_RPC
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// struct FString                 Cmd                            (Parm, ZeroConstructor)

void ASTExtraPlayerController::ServerCMD_RPC(const struct FString& Cmd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerCMD_RPC");

	ASTExtraPlayerController_ServerCMD_RPC_Params params;
	params.Cmd = Cmd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerCMD
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 Cmd                            (Parm, ZeroConstructor)

void ASTExtraPlayerController::ServerCMD(const struct FString& Cmd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerCMD");

	ASTExtraPlayerController_ServerCMD_Params params;
	params.Cmd = Cmd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ServerClearTeammatesCache
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::ServerClearTeammatesCache()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ServerClearTeammatesCache");

	ASTExtraPlayerController_ServerClearTeammatesCache_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SendStringMsg
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 Message                        (Parm, ZeroConstructor)
// int                            msgID                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::SendStringMsg(const struct FString& Message, int msgID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SendStringMsg");

	ASTExtraPlayerController_SendStringMsg_Params params;
	params.Message = Message;
	params.msgID = msgID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SendEndTouchScreenUICommand
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FString                 UIMsg                          (Parm, OutParm, ZeroConstructor)

void ASTExtraPlayerController::SendEndTouchScreenUICommand(struct FString* UIMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SendEndTouchScreenUICommand");

	ASTExtraPlayerController_SendEndTouchScreenUICommand_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (UIMsg != nullptr)
		*UIMsg = params.UIMsg;
}


// Function ShadowTrackerExtra.STExtraPlayerController.SendDeviceInfo
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FString                 PlatformProfileName            (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// struct FDeviceInfo             DeviceInfo                     (ConstParm, Parm, ReferenceParm)

void ASTExtraPlayerController::SendDeviceInfo(const struct FString& PlatformProfileName, const struct FDeviceInfo& DeviceInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.SendDeviceInfo");

	ASTExtraPlayerController_SendDeviceInfo_Params params;
	params.PlatformProfileName = PlatformProfileName;
	params.DeviceInfo = DeviceInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ScopeOut
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::ScopeOut()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ScopeOut");

	ASTExtraPlayerController_ScopeOut_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ScopeIn
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::ScopeIn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ScopeIn");

	ASTExtraPlayerController_ScopeIn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.S2C_ResponseSkillPrompt
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingTime                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 PromptText                     (Parm, ZeroConstructor)
// float                          TotalTime                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::S2C_ResponseSkillPrompt(bool bShow, float RemainingTime, const struct FString& PromptText, float TotalTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.S2C_ResponseSkillPrompt");

	ASTExtraPlayerController_S2C_ResponseSkillPrompt_Params params;
	params.bShow = bShow;
	params.RemainingTime = RemainingTime;
	params.PromptText = PromptText;
	params.TotalTime = TotalTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.S2C_HelpOther
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// class ACharacter*              HelpWho                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurnInfo                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingRescueTime            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::S2C_HelpOther(class ACharacter* HelpWho, bool IsTurnInfo, float RemainingRescueTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.S2C_HelpOther");

	ASTExtraPlayerController_S2C_HelpOther_Params params;
	params.HelpWho = HelpWho;
	params.IsTurnInfo = IsTurnInfo;
	params.RemainingRescueTime = RemainingRescueTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.S2C_BeHelpedByOther
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// class ACharacter*              ByWho                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurnInfo                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingRescueTime            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::S2C_BeHelpedByOther(class ACharacter* ByWho, bool IsTurnInfo, float RemainingRescueTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.S2C_BeHelpedByOther");

	ASTExtraPlayerController_S2C_BeHelpedByOther_Params params;
	params.ByWho = ByWho;
	params.IsTurnInfo = IsTurnInfo;
	params.RemainingRescueTime = RemainingRescueTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RunOnNextFrameEvent
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::RunOnNextFrameEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RunOnNextFrameEvent");

	ASTExtraPlayerController_RunOnNextFrameEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.RunOnNextFrame__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::RunOnNextFrame__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.RunOnNextFrame__DelegateSignature");

	ASTExtraPlayerController_RunOnNextFrame__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ShootSpecialBullet
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FTransform              LaunchTrans                    (Parm, IsPlainOldData)
// class ASTExtraShootWeapon*     TargetWeapon                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_Server_ShootSpecialBullet(const struct FTransform& LaunchTrans, class ASTExtraShootWeapon* TargetWeapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ShootSpecialBullet");

	ASTExtraPlayerController_RPC_Server_ShootSpecialBullet_Params params;
	params.LaunchTrans = LaunchTrans;
	params.TargetWeapon = TargetWeapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NotifySwapMainWeaponFinished
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot1                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot2                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_Server_NotifySwapMainWeaponFinished(TEnumAsByte<ESurviveWeaponPropSlot> Slot1, TEnumAsByte<ESurviveWeaponPropSlot> Slot2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NotifySwapMainWeaponFinished");

	ASTExtraPlayerController_RPC_Server_NotifySwapMainWeaponFinished_Params params;
	params.Slot1 = Slot1;
	params.Slot2 = Slot2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NotifyBreakWindow
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class AUAEHouseActor*          OwnerTarget                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FUAEWindowRepData       Window                         (Parm)

void ASTExtraPlayerController::RPC_Server_NotifyBreakWindow(class AUAEHouseActor* OwnerTarget, const struct FUAEWindowRepData& Window)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NotifyBreakWindow");

	ASTExtraPlayerController_RPC_Server_NotifyBreakWindow_Params params;
	params.OwnerTarget = OwnerTarget;
	params.Window = Window;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerClientHasFinishReconnectedWeaponSystem
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::RPC_Server_NorifyServerClientHasFinishReconnectedWeaponSystem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerClientHasFinishReconnectedWeaponSystem");

	ASTExtraPlayerController_RPC_Server_NorifyServerClientHasFinishReconnectedWeaponSystem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerClientHasFinishedHandleSpawnWeapon
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           bFinishAllWeapon               (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FItemDefineID>   WeaponIDArray                  (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::RPC_Server_NorifyServerClientHasFinishedHandleSpawnWeapon(bool bFinishAllWeapon, TArray<struct FItemDefineID> WeaponIDArray)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerClientHasFinishedHandleSpawnWeapon");

	ASTExtraPlayerController_RPC_Server_NorifyServerClientHasFinishedHandleSpawnWeapon_Params params;
	params.bFinishAllWeapon = bFinishAllWeapon;
	params.WeaponIDArray = WeaponIDArray;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerAddFirstOpenedAirDropBoxes
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TArray<int>                    AirDropBoxIDArray              (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::RPC_Server_NorifyServerAddFirstOpenedAirDropBoxes(TArray<int> AirDropBoxIDArray)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_NorifyServerAddFirstOpenedAirDropBoxes");

	ASTExtraPlayerController_RPC_Server_NorifyServerAddFirstOpenedAirDropBoxes_Params params;
	params.AirDropBoxIDArray = AirDropBoxIDArray;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ClientHasReactivated
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void ASTExtraPlayerController::RPC_Server_ClientHasReactivated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ClientHasReactivated");

	ASTExtraPlayerController_RPC_Server_ClientHasReactivated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ClientHasFinishedRecoverWeapon
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FWeaponReconnectReplicateData RecoverData                    (ConstParm, Parm, ReferenceParm)

void ASTExtraPlayerController::RPC_Server_ClientHasFinishedRecoverWeapon(class ASTExtraWeapon* Weapon, const struct FWeaponReconnectReplicateData& RecoverData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Server_ClientHasFinishedRecoverWeapon");

	ASTExtraPlayerController_RPC_Server_ClientHasFinishedRecoverWeapon_Params params;
	params.Weapon = Weapon;
	params.RecoverData = RecoverData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_RequireDynamicWeatherInfo
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// class ADynamicWeatherMgr*      DynamicWeatherMgr              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_RequireDynamicWeatherInfo(class ADynamicWeatherMgr* DynamicWeatherMgr)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_RequireDynamicWeatherInfo");

	ASTExtraPlayerController_RPC_RequireDynamicWeatherInfo_Params params;
	params.DynamicWeatherMgr = DynamicWeatherMgr;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_PushDynamicWeatherInfo
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ADynamicWeatherMgr*      DynamicWeatherMgr              (Parm, ZeroConstructor, IsPlainOldData)
// struct FWeatherControllerRepData RepWeatherInfo                 (Parm)

void ASTExtraPlayerController::RPC_PushDynamicWeatherInfo(class ADynamicWeatherMgr* DynamicWeatherMgr, const struct FWeatherControllerRepData& RepWeatherInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_PushDynamicWeatherInfo");

	ASTExtraPlayerController_RPC_PushDynamicWeatherInfo_Params params;
	params.DynamicWeatherMgr = DynamicWeatherMgr;
	params.RepWeatherInfo = RepWeatherInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SwapWeaponByPropSlot
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot1                          (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot2                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForce                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_SwapWeaponByPropSlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot1, TEnumAsByte<ESurviveWeaponPropSlot> Slot2, bool bForce)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SwapWeaponByPropSlot");

	ASTExtraPlayerController_RPC_OwnerClient_SwapWeaponByPropSlot_Params params;
	params.Slot1 = Slot1;
	params.Slot2 = Slot2;
	params.bForce = bForce;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetMurderInfo
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FString                 murderName                     (Parm, ZeroConstructor)
// bool                           IsAI                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 murderUID                      (Parm, ZeroConstructor)

void ASTExtraPlayerController::RPC_OwnerClient_SetMurderInfo(const struct FString& murderName, bool IsAI, const struct FString& murderUID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetMurderInfo");

	ASTExtraPlayerController_RPC_OwnerClient_SetMurderInfo_Params params;
	params.murderName = murderName;
	params.IsAI = IsAI;
	params.murderUID = murderUID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetLastBreathMurder
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FString                 MurderPlayerName               (Parm, ZeroConstructor)
// bool                           IsAI                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 murderUID                      (Parm, ZeroConstructor)

void ASTExtraPlayerController::RPC_OwnerClient_SetLastBreathMurder(const struct FString& MurderPlayerName, bool IsAI, const struct FString& murderUID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetLastBreathMurder");

	ASTExtraPlayerController_RPC_OwnerClient_SetLastBreathMurder_Params params;
	params.MurderPlayerName = MurderPlayerName;
	params.IsAI = IsAI;
	params.murderUID = murderUID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetCurrentWeaponVisible
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// bool                           bVisible                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_SetCurrentWeaponVisible(bool bVisible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_SetCurrentWeaponVisible");

	ASTExtraPlayerController_RPC_OwnerClient_SetCurrentWeaponVisible_Params params;
	params.bVisible = bVisible;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerEnableAttrModifier
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FAttrModifyItem         ItemData                       (ConstParm, Parm, ReferenceParm)

void ASTExtraPlayerController::RPC_OwnerClient_PlayerEnableAttrModifier(bool bEnable, const struct FAttrModifyItem& ItemData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerEnableAttrModifier");

	ASTExtraPlayerController_RPC_OwnerClient_PlayerEnableAttrModifier_Params params;
	params.bEnable = bEnable;
	params.ItemData = ItemData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerConsumeItem
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FItemDefineID           ID                             (ConstParm, Parm, ReferenceParm)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_PlayerConsumeItem(const struct FItemDefineID& ID, int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerConsumeItem");

	ASTExtraPlayerController_RPC_OwnerClient_PlayerConsumeItem_Params params;
	params.ID = ID;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerAddHealth
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ERecoveryReasonType> Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_PlayerAddHealth(float AddVal, TEnumAsByte<ERecoveryReasonType> Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerAddHealth");

	ASTExtraPlayerController_RPC_OwnerClient_PlayerAddHealth_Params params;
	params.AddVal = AddVal;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerAddEnergy
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ERecoveryReasonType> Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_PlayerAddEnergy(float AddVal, TEnumAsByte<ERecoveryReasonType> Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_PlayerAddEnergy");

	ASTExtraPlayerController_RPC_OwnerClient_PlayerAddEnergy_Params params;
	params.AddVal = AddVal;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_NotifyClientEquipWeaponAttachment
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           DefineID                       (ConstParm, Parm, ReferenceParm)
// bool                           bEquip                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_NotifyClientEquipWeaponAttachment(TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot, const struct FItemDefineID& DefineID, bool bEquip)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_NotifyClientEquipWeaponAttachment");

	ASTExtraPlayerController_RPC_OwnerClient_NotifyClientEquipWeaponAttachment_Params params;
	params.WeaponPropSlot = WeaponPropSlot;
	params.DefineID = DefineID;
	params.bEquip = bEquip;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_HandleAIShootBulletHit
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient, NetValidate)
// Parameters:
// struct FVector                 BulletStart                    (Parm, IsPlainOldData)
// struct FVector                 BulletEnd                      (Parm, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_HandleAIShootBulletHit(const struct FVector& BulletStart, const struct FVector& BulletEnd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_HandleAIShootBulletHit");

	ASTExtraPlayerController_RPC_OwnerClient_HandleAIShootBulletHit_Params params;
	params.BulletStart = BulletStart;
	params.BulletEnd = BulletEnd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_ClientPlayItemOperationSound
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FString                 BankName                       (Parm, ZeroConstructor)
// struct FString                 SoundName                      (Parm, ZeroConstructor)
// class AActor*                  TargetActor                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_OwnerClient_ClientPlayItemOperationSound(const struct FString& BankName, const struct FString& SoundName, class AActor* TargetActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_ClientPlayItemOperationSound");

	ASTExtraPlayerController_RPC_OwnerClient_ClientPlayItemOperationSound_Params params;
	params.BankName = BankName;
	params.SoundName = SoundName;
	params.TargetActor = TargetActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_ClearAllInventoryData
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)

void ASTExtraPlayerController::RPC_OwnerClient_ClearAllInventoryData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_OwnerClient_ClearAllInventoryData");

	ASTExtraPlayerController_RPC_OwnerClient_ClearAllInventoryData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_DrawDebug_Sphere
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 Center                         (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  Color                          (Parm, IsPlainOldData)
// float                          LifeTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_DrawDebug_Sphere(const struct FVector& Center, float Radius, const struct FColor& Color, float LifeTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_DrawDebug_Sphere");

	ASTExtraPlayerController_RPC_DrawDebug_Sphere_Params params;
	params.Center = Center;
	params.Radius = Radius;
	params.Color = Color;
	params.LifeTime = LifeTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_DrawDebug_Line
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 Start                          (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 End                            (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FColor                  Color                          (Parm, IsPlainOldData)
// float                          LifeTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_DrawDebug_Line(const struct FVector& Start, const struct FVector& End, const struct FColor& Color, float LifeTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_DrawDebug_Line");

	ASTExtraPlayerController_RPC_DrawDebug_Line_Params params;
	params.Start = Start;
	params.End = End;
	params.Color = Color;
	params.LifeTime = LifeTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_PlayerBulletHitVehicleSound
// (Net, Native, Event, Public, HasDefaults, NetClient, NetValidate)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// struct FRotator                Rot                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::RPC_Client_PlayerBulletHitVehicleSound(const struct FVector& Loc, const struct FRotator& Rot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_PlayerBulletHitVehicleSound");

	ASTExtraPlayerController_RPC_Client_PlayerBulletHitVehicleSound_Params params;
	params.Loc = Loc;
	params.Rot = Rot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_OnDamageNotifyRecord
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// int                            DamagerID                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAI                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          fHealth                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            OtherHealthStatus              (Parm, ZeroConstructor, IsPlainOldData)
// float                          ShootDistance                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   causerName                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_Client_OnDamageNotifyRecord(int DamagerID, bool bAI, float fHealth, int OtherHealthStatus, float ShootDistance, int DamageType, const struct FName& causerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_OnDamageNotifyRecord");

	ASTExtraPlayerController_RPC_Client_OnDamageNotifyRecord_Params params;
	params.DamagerID = DamagerID;
	params.bAI = bAI;
	params.fHealth = fHealth;
	params.OtherHealthStatus = OtherHealthStatus;
	params.ShootDistance = ShootDistance;
	params.DamageType = DamageType;
	params.causerName = causerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_DestroyWeapon
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FName                   LogicSocket                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ID                             (ConstParm, Parm, ReferenceParm)
// bool                           bEnableBroadcast               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_Client_DestroyWeapon(const struct FName& LogicSocket, const struct FItemDefineID& ID, bool bEnableBroadcast)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_DestroyWeapon");

	ASTExtraPlayerController_RPC_Client_DestroyWeapon_Params params;
	params.LogicSocket = LogicSocket;
	params.ID = ID;
	params.bEnableBroadcast = bEnableBroadcast;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_ClientDisplayScoreChangeTips
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// struct FWarPlayerStateScore    ScoreStruct                    (Parm)

void ASTExtraPlayerController::RPC_Client_ClientDisplayScoreChangeTips(const struct FWarPlayerStateScore& ScoreStruct)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_ClientDisplayScoreChangeTips");

	ASTExtraPlayerController_RPC_Client_ClientDisplayScoreChangeTips_Params params;
	params.ScoreStruct = ScoreStruct;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_CircleRun
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            TotalNum                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RPC_Client_CircleRun(int Index, int TotalNum)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RPC_Client_CircleRun");

	ASTExtraPlayerController_RPC_Client_CircleRun_Params params;
	params.Index = Index;
	params.TotalNum = TotalNum;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RetriveMobileContentScaleFactor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerController::RetriveMobileContentScaleFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RetriveMobileContentScaleFactor");

	ASTExtraPlayerController_RetriveMobileContentScaleFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RestoreDefaultInteractionSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            JSIndex                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RestoreDefaultInteractionSize(int JSIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RestoreDefaultInteractionSize");

	ASTExtraPlayerController_RestoreDefaultInteractionSize_Params params;
	params.JSIndex = JSIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RestartAI
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::RestartAI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RestartAI");

	ASTExtraPlayerController_RestartAI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RespawnRecoverData
// (Final, Native, Public)
// Parameters:
// class AUAEPlayerController*    PC                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RespawnRecoverData(class AUAEPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RespawnRecoverData");

	ASTExtraPlayerController_RespawnRecoverData_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ResetMissingUIUpdate
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerController::ResetMissingUIUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ResetMissingUIUpdate");

	ASTExtraPlayerController_ResetMissingUIUpdate_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RequireNetCullingDistanceByDevice
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::RequireNetCullingDistanceByDevice()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RequireNetCullingDistanceByDevice");

	ASTExtraPlayerController_RequireNetCullingDistanceByDevice_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RequireDeviceInfo
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::RequireDeviceInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RequireDeviceInfo");

	ASTExtraPlayerController_RequireDeviceInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RequestPlayerNewbieInfo
// (Final, Native, Public)

void ASTExtraPlayerController::RequestPlayerNewbieInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RequestPlayerNewbieInfo");

	ASTExtraPlayerController_RequestPlayerNewbieInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ReqSwitchPersonPerspective
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           IsNewFPP                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ReqSwitchPersonPerspective(bool IsNewFPP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ReqSwitchPersonPerspective");

	ASTExtraPlayerController_ReqSwitchPersonPerspective_Params params;
	params.IsNewFPP = IsNewFPP;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ReportWatchGamePlayerInfoButtonClick
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::ReportWatchGamePlayerInfoButtonClick()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ReportWatchGamePlayerInfoButtonClick");

	ASTExtraPlayerController_ReportWatchGamePlayerInfoButtonClick_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RemoveTouchMoveFinger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RemoveTouchMoveFinger(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RemoveTouchMoveFinger");

	ASTExtraPlayerController_RemoveTouchMoveFinger_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RemoveAllDoors
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::RemoveAllDoors()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RemoveAllDoors");

	ASTExtraPlayerController_RemoveAllDoors_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ReInitUIAfterReCreatePawn
// (Final, Native, Public)
// Parameters:
// class AUAEPlayerController*    UAEPC                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ReInitUIAfterReCreatePawn(class AUAEPlayerController* UAEPC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ReInitUIAfterReCreatePawn");

	ASTExtraPlayerController_ReInitUIAfterReCreatePawn_Params params;
	params.UAEPC = UAEPC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RefreshTopMostUIPanel
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<ETopMostUIPanelType> Type                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::RefreshTopMostUIPanel(TEnumAsByte<ETopMostUIPanelType> Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RefreshTopMostUIPanel");

	ASTExtraPlayerController_RefreshTopMostUIPanel_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.RecordPathPoint
// (Final, Native, Private, BlueprintCallable)

void ASTExtraPlayerController::RecordPathPoint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.RecordPathPoint");

	ASTExtraPlayerController_RecordPathPoint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ReceiveClientRestart
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerController::ReceiveClientRestart()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ReceiveClientRestart");

	ASTExtraPlayerController_ReceiveClientRestart_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ReceiveBackpackComponent
// (Native, Event, Protected, BlueprintEvent)

void ASTExtraPlayerController::ReceiveBackpackComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ReceiveBackpackComponent");

	ASTExtraPlayerController_ReceiveBackpackComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PrintStringToScreen
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FString                 inString                       (Parm, ZeroConstructor)
// struct FLinearColor            TextColor                      (Parm, IsPlainOldData)
// float                          Duration                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PrintStringToScreen(const struct FString& inString, const struct FLinearColor& TextColor, float Duration)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PrintStringToScreen");

	ASTExtraPlayerController_PrintStringToScreen_Params params;
	params.inString = inString;
	params.TextColor = TextColor;
	params.Duration = Duration;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PrintMovementLog
// (Final, Exec, Native, Public)
// Parameters:
// int                            PrintLog                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PrintMovementLog(int PrintLog)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PrintMovementLog");

	ASTExtraPlayerController_PrintMovementLog_Params params;
	params.PrintLog = PrintLog;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PrintDownCollision
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::PrintDownCollision()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PrintDownCollision");

	ASTExtraPlayerController_PrintDownCollision_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PressGrenade
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           isThrow                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PressGrenade(bool isThrow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PressGrenade");

	ASTExtraPlayerController_PressGrenade_Params params;
	params.isThrow = isThrow;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PressFire
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PressFire(int FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PressFire");

	ASTExtraPlayerController_PressFire_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PlayItemOperationSoundByBP
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 BankName                       (Parm, ZeroConstructor)
// struct FString                 SoundName                      (Parm, ZeroConstructor)
// class AActor*                  TargetActor                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PlayItemOperationSoundByBP(const struct FString& BankName, const struct FString& SoundName, class AActor* TargetActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PlayItemOperationSoundByBP");

	ASTExtraPlayerController_PlayItemOperationSoundByBP_Params params;
	params.BankName = BankName;
	params.SoundName = SoundName;
	params.TargetActor = TargetActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.PlayerLiveStateChangedInOB
// (Final, Native, Public)
// Parameters:
// ExtraPlayerLiveState           State                          (Parm, ZeroConstructor, IsPlainOldData)
// class ACharacter*              OwnerCharacter                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PlayerLiveStateChangedInOB(ExtraPlayerLiveState State, class ACharacter* OwnerCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.PlayerLiveStateChangedInOB");

	ASTExtraPlayerController_PlayerLiveStateChangedInOB_Params params;
	params.State = State;
	params.OwnerCharacter = OwnerCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerKillingDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::PlayerKillingDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerKillingDelegate__DelegateSignature");

	ASTExtraPlayerController_PlayerKillingDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerEnterAreaDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            AreaID                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PlayerEnterAreaDelegate__DelegateSignature(int AreaID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerEnterAreaDelegate__DelegateSignature");

	ASTExtraPlayerController_PlayerEnterAreaDelegate__DelegateSignature_Params params;
	params.AreaID = AreaID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerDoEmoteDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PlayerDoEmoteDelegate__DelegateSignature(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerDoEmoteDelegate__DelegateSignature");

	ASTExtraPlayerController_PlayerDoEmoteDelegate__DelegateSignature_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerControllerToggleDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           bOpen                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::PlayerControllerToggleDelegate__DelegateSignature(bool bOpen)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.PlayerControllerToggleDelegate__DelegateSignature");

	ASTExtraPlayerController_PlayerControllerToggleDelegate__DelegateSignature_Params params;
	params.bOpen = bOpen;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OpenParachute
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OpenParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OpenParachute");

	ASTExtraPlayerController_OpenParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnWeaponEquipAttachmentDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasOutParms)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           DefineID                       (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           bEquip                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnWeaponEquipAttachmentDelegate__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot, const struct FItemDefineID& DefineID, bool bEquip)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnWeaponEquipAttachmentDelegate__DelegateSignature");

	ASTExtraPlayerController_OnWeaponEquipAttachmentDelegate__DelegateSignature_Params params;
	params.WeaponPropSlot = WeaponPropSlot;
	params.DefineID = DefineID;
	params.bEquip = bEquip;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnWeaponEquipAttachment
// (Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           DefineID                       (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           bEquip                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnWeaponEquipAttachment(TEnumAsByte<ESurviveWeaponPropSlot> WeaponPropSlot, const struct FItemDefineID& DefineID, bool bEquip)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnWeaponEquipAttachment");

	ASTExtraPlayerController_OnWeaponEquipAttachment_Params params;
	params.WeaponPropSlot = WeaponPropSlot;
	params.DefineID = DefineID;
	params.bEquip = bEquip;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnWallFeedBack
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           _WallFeedBack                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnWallFeedBack(bool _WallFeedBack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnWallFeedBack");

	ASTExtraPlayerController_OnWallFeedBack_Params params;
	params._WallFeedBack = _WallFeedBack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetPoseChanged
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastPose                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     NewPose                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnViewTargetPoseChanged(TEnumAsByte<ESTEPoseState> LastPose, TEnumAsByte<ESTEPoseState> NewPose)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetPoseChanged");

	ASTExtraPlayerController_OnViewTargetPoseChanged_Params params;
	params.LastPose = LastPose;
	params.NewPose = NewPose;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargeteRespawnCDChanged
// (Final, Native, Public)

void ASTExtraPlayerController::OnViewTargeteRespawnCDChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargeteRespawnCDChanged");

	ASTExtraPlayerController_OnViewTargeteRespawnCDChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetDetachedFromVehicle
// (Final, Native, Public)

void ASTExtraPlayerController::OnViewTargetDetachedFromVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetDetachedFromVehicle");

	ASTExtraPlayerController_OnViewTargetDetachedFromVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetChangeVehicleSeat
// (Final, Native, Public)

void ASTExtraPlayerController::OnViewTargetChangeVehicleSeat()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetChangeVehicleSeat");

	ASTExtraPlayerController_OnViewTargetChangeVehicleSeat_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetAttachedToVehicle
// (Final, Native, Public)
// Parameters:
// class ASTExtraVehicleBase*     InVehicle                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnViewTargetAttachedToVehicle(class ASTExtraVehicleBase* InVehicle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnViewTargetAttachedToVehicle");

	ASTExtraPlayerController_OnViewTargetAttachedToVehicle_Params params;
	params.InVehicle = InVehicle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUseMainSlot__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnUseMainSlot__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUseMainSlot__DelegateSignature");

	ASTExtraPlayerController_OnUseMainSlot__DelegateSignature_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUseInventoryItemDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnUseInventoryItemDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUseInventoryItemDelegate__DelegateSignature");

	ASTExtraPlayerController_OnUseInventoryItemDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUnequipWeaponDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnUnequipWeaponDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnUnequipWeaponDelegate__DelegateSignature");

	ASTExtraPlayerController_OnUnequipWeaponDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnTeammatesAllDie
// (Final, Native, Public)

void ASTExtraPlayerController::OnTeammatesAllDie()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnTeammatesAllDie");

	ASTExtraPlayerController_OnTeammatesAllDie_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnTeammateLogin
// (Final, Native, Public)
// Parameters:
// int                            InTeamID                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnTeammateLogin(int InTeamID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnTeammateLogin");

	ASTExtraPlayerController_OnTeammateLogin_Params params;
	params.InTeamID = InTeamID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTeammateHPChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnTeammateHPChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTeammateHPChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_OnTeammateHPChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTaskConditionDeactivedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ETaskConditionType> TaskConditionType              (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            DataSource                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnTaskConditionDeactivedDelegate__DelegateSignature(TEnumAsByte<ETaskConditionType> TaskConditionType, class UVariableSet* DataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTaskConditionDeactivedDelegate__DelegateSignature");

	ASTExtraPlayerController_OnTaskConditionDeactivedDelegate__DelegateSignature_Params params;
	params.TaskConditionType = TaskConditionType;
	params.DataSource = DataSource;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTaskConditionActivedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ETaskConditionType> TaskConditionType              (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            DataSource                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnTaskConditionActivedDelegate__DelegateSignature(TEnumAsByte<ETaskConditionType> TaskConditionType, class UVariableSet* DataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTaskConditionActivedDelegate__DelegateSignature");

	ASTExtraPlayerController_OnTaskConditionActivedDelegate__DelegateSignature_Params params;
	params.TaskConditionType = TaskConditionType;
	params.DataSource = DataSource;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTakeDamaged__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          DamageAngel                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnTakeDamaged__DelegateSignature(float DamageAngel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnTakeDamaged__DelegateSignature");

	ASTExtraPlayerController_OnTakeDamaged__DelegateSignature_Params params;
	params.DamageAngel = DamageAngel;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchWeaponDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnSwitchWeaponDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchWeaponDelegate__DelegateSignature");

	ASTExtraPlayerController_OnSwitchWeaponDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchCameraModeStartDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> CameraMode                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnSwitchCameraModeStartDelegate__DelegateSignature(TEnumAsByte<EPlayerCameraMode> CameraMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchCameraModeStartDelegate__DelegateSignature");

	ASTExtraPlayerController_OnSwitchCameraModeStartDelegate__DelegateSignature_Params params;
	params.CameraMode = CameraMode;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchCameraModeEndDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> CameraMode                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnSwitchCameraModeEndDelegate__DelegateSignature(TEnumAsByte<EPlayerCameraMode> CameraMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSwitchCameraModeEndDelegate__DelegateSignature");

	ASTExtraPlayerController_OnSwitchCameraModeEndDelegate__DelegateSignature_Params params;
	params.CameraMode = CameraMode;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStopFireDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnStopFireDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStopFireDelegate__DelegateSignature");

	ASTExtraPlayerController_OnStopFireDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStartFireDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnStartFireDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStartFireDelegate__DelegateSignature");

	ASTExtraPlayerController_OnStartFireDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStartAutoSprintCountDown__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnStartAutoSprintCountDown__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnStartAutoSprintCountDown__DelegateSignature");

	ASTExtraPlayerController_OnStartAutoSprintCountDown__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSpectatorChange__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnSpectatorChange__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnSpectatorChange__DelegateSignature");

	ASTExtraPlayerController_OnSpectatorChange__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnSpectatorCameraChange
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bDie                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnSpectatorCameraChange(bool bDie)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnSpectatorCameraChange");

	ASTExtraPlayerController_OnSpectatorCameraChange_Params params;
	params.bDie = bDie;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnShowSkillPromptDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           IsShowPrompt                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          LastTime                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 PromptText                     (Parm, ZeroConstructor)
// float                          TotalTime                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnShowSkillPromptDelegate__DelegateSignature(bool IsShowPrompt, float LastTime, const struct FString& PromptText, float TotalTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnShowSkillPromptDelegate__DelegateSignature");

	ASTExtraPlayerController_OnShowSkillPromptDelegate__DelegateSignature_Params params;
	params.IsShowPrompt = IsShowPrompt;
	params.LastTime = LastTime;
	params.PromptText = PromptText;
	params.TotalTime = TotalTime;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnShowAutoSprintButton__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// bool                           Visible                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               showPos                        (Parm, IsPlainOldData)
// bool                           IsInside                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnShowAutoSprintButton__DelegateSignature(bool Visible, const struct FVector2D& showPos, bool IsInside)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnShowAutoSprintButton__DelegateSignature");

	ASTExtraPlayerController_OnShowAutoSprintButton__DelegateSignature_Params params;
	params.Visible = Visible;
	params.showPos = showPos;
	params.IsInside = IsInside;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRepTeammateChange__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnRepTeammateChange__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRepTeammateChange__DelegateSignature");

	ASTExtraPlayerController_OnRepTeammateChange__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRepPlayerState__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnRepPlayerState__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRepPlayerState__DelegateSignature");

	ASTExtraPlayerController_OnRepPlayerState__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRepNotify_SetBattleOwner
// (Final, Native, Public)

void ASTExtraPlayerController::OnRepNotify_SetBattleOwner()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRepNotify_SetBattleOwner");

	ASTExtraPlayerController_OnRepNotify_SetBattleOwner_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRepNotify_ServerHitEnemyReplicatedData
// (Final, Native, Public)

void ASTExtraPlayerController::OnRepNotify_ServerHitEnemyReplicatedData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRepNotify_ServerHitEnemyReplicatedData");

	ASTExtraPlayerController_OnRepNotify_ServerHitEnemyReplicatedData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_WeaponSystemReconnectReplicateData
// (Final, Native, Protected)

void ASTExtraPlayerController::OnRep_WeaponSystemReconnectReplicateData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_WeaponSystemReconnectReplicateData");

	ASTExtraPlayerController_OnRep_WeaponSystemReconnectReplicateData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_STExtraBaseCharacter
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_STExtraBaseCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_STExtraBaseCharacter");

	ASTExtraPlayerController_OnRep_STExtraBaseCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ServerStateType
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_ServerStateType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ServerStateType");

	ASTExtraPlayerController_OnRep_ServerStateType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_RefreshTotalPlayers
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_RefreshTotalPlayers()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_RefreshTotalPlayers");

	ASTExtraPlayerController_OnRep_RefreshTotalPlayers_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_RefreshAirDropBox
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_RefreshAirDropBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_RefreshAirDropBox");

	ASTExtraPlayerController_OnRep_RefreshAirDropBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_Plane
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_Plane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_Plane");

	ASTExtraPlayerController_OnRep_Plane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ObservedItemList
// (Final, Native, Private)

void ASTExtraPlayerController::OnRep_ObservedItemList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ObservedItemList");

	ASTExtraPlayerController_OnRep_ObservedItemList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_KillTipInfoFilterTemplatesPathList
// (Final, Native, Protected)

void ASTExtraPlayerController::OnRep_KillTipInfoFilterTemplatesPathList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_KillTipInfoFilterTemplatesPathList");

	ASTExtraPlayerController_OnRep_KillTipInfoFilterTemplatesPathList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ImprisonmentTeammateSucess
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_ImprisonmentTeammateSucess()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_ImprisonmentTeammateSucess");

	ASTExtraPlayerController_OnRep_ImprisonmentTeammateSucess_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_FiringPlayerList
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_FiringPlayerList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_FiringPlayerList");

	ASTExtraPlayerController_OnRep_FiringPlayerList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_DeadTombBox
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_DeadTombBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_DeadTombBox");

	ASTExtraPlayerController_OnRep_DeadTombBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_CanOpenParachute
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_CanOpenParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_CanOpenParachute");

	ASTExtraPlayerController_OnRep_CanOpenParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_CanJump
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_CanJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_CanJump");

	ASTExtraPlayerController_OnRep_CanJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_BlackEntTime
// (Final, Native, Public)

void ASTExtraPlayerController::OnRep_BlackEntTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_BlackEntTime");

	ASTExtraPlayerController_OnRep_BlackEntTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnRep_BackpackComponent
// (Final, Native, Private)

void ASTExtraPlayerController::OnRep_BackpackComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnRep_BackpackComponent");

	ASTExtraPlayerController_OnRep_BackpackComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRemoveMainSlot__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnRemoveMainSlot__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRemoveMainSlot__DelegateSignature");

	ASTExtraPlayerController_OnRemoveMainSlot__DelegateSignature_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReleaseScreen__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnReleaseScreen__DelegateSignature(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReleaseScreen__DelegateSignature");

	ASTExtraPlayerController_OnReleaseScreen__DelegateSignature_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReleaseFireBtnDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnReleaseFireBtnDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReleaseFireBtnDelegate__DelegateSignature");

	ASTExtraPlayerController_OnReleaseFireBtnDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReconnected__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnReconnected__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnReconnected__DelegateSignature");

	ASTExtraPlayerController_OnReconnected__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRank__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            Kills                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Rank                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnRank__DelegateSignature(int Kills, int Rank)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnRank__DelegateSignature");

	ASTExtraPlayerController_OnRank__DelegateSignature_Params params;
	params.Kills = Kills;
	params.Rank = Rank;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerUseRecoverItem
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnPlayerUseRecoverItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerUseRecoverItem");

	ASTExtraPlayerController_OnPlayerUseRecoverItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerStateChanged
// (Final, Native, Public)

void ASTExtraPlayerController::OnPlayerStateChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerStateChanged");

	ASTExtraPlayerController_OnPlayerStateChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerReConnected
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// int                            LostPlayerKey                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerReConnected(int LostPlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerReConnected");

	ASTExtraPlayerController_OnPlayerReConnected_Params params;
	params.LostPlayerKey = LostPlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPutDownAllPropDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnPlayerPutDownAllPropDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPutDownAllPropDelegate__DelegateSignature");

	ASTExtraPlayerController_OnPlayerPutDownAllPropDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPutDownActorDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetPlayer                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  TargetActor                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerPutDownActorDelegate__DelegateSignature(class ASTExtraBaseCharacter* TargetPlayer, class AActor* TargetActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPutDownActorDelegate__DelegateSignature");

	ASTExtraPlayerController_OnPlayerPutDownActorDelegate__DelegateSignature_Params params;
	params.TargetPlayer = TargetPlayer;
	params.TargetActor = TargetActor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPickUpActorDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurvivePickUpGlobalCategory> SurvivePickUpGlobalCategory    (Parm, ZeroConstructor, IsPlainOldData)
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerPickUpActorDelegate__DelegateSignature(TEnumAsByte<ESurvivePickUpGlobalCategory> SurvivePickUpGlobalCategory, int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerPickUpActorDelegate__DelegateSignature");

	ASTExtraPlayerController_OnPlayerPickUpActorDelegate__DelegateSignature_Params params;
	params.SurvivePickUpGlobalCategory = SurvivePickUpGlobalCategory;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerNameChange__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// struct FString                 changedplayername              (Parm, ZeroConstructor)

void ASTExtraPlayerController::OnPlayerNameChange__DelegateSignature(const struct FString& changedplayername)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPlayerNameChange__DelegateSignature");

	ASTExtraPlayerController_OnPlayerNameChange__DelegateSignature_Params params;
	params.changedplayername = changedplayername;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerLostConnection
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// int                            LostPlayerKey                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerLostConnection(int LostPlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerLostConnection");

	ASTExtraPlayerController_OnPlayerLostConnection_Params params;
	params.LostPlayerKey = LostPlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerHitFireBtn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bIsRightBtn                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerHitFireBtn(bool bIsRightBtn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerHitFireBtn");

	ASTExtraPlayerController_OnPlayerHitFireBtn_Params params;
	params.bIsRightBtn = bIsRightBtn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerClickDriveBtn
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnPlayerClickDriveBtn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerClickDriveBtn");

	ASTExtraPlayerController_OnPlayerClickDriveBtn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerCanGetInVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           CanGetInVehicle                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPlayerCanGetInVehicle(bool CanGetInVehicle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPlayerCanGetInVehicle");

	ASTExtraPlayerController_OnPlayerCanGetInVehicle_Params params;
	params.CanGetInVehicle = CanGetInVehicle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPickupItemDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPickupItemDelegate__DelegateSignature(int ItemID, int Count, class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnPickupItemDelegate__DelegateSignature");

	ASTExtraPlayerController_OnPickupItemDelegate__DelegateSignature_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPickUpExpand
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnPickUpExpand()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPickUpExpand");

	ASTExtraPlayerController_OnPickUpExpand_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnPickUpCollapsed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           isCollapsed                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnPickUpCollapsed(bool isCollapsed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnPickUpCollapsed");

	ASTExtraPlayerController_OnPickUpCollapsed_Params params;
	params.isCollapsed = isCollapsed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnObserverLevelLoaded
// (Final, Native, Public)

void ASTExtraPlayerController::OnObserverLevelLoaded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnObserverLevelLoaded");

	ASTExtraPlayerController_OnObserverLevelLoaded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnObservedUsingWeaponChanged
// (Final, Native, Public)

void ASTExtraPlayerController::OnObservedUsingWeaponChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnObservedUsingWeaponChanged");

	ASTExtraPlayerController_OnObservedUsingWeaponChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnObservedItemsChanged
// (Final, Native, Public)

void ASTExtraPlayerController::OnObservedItemsChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnObservedItemsChanged");

	ASTExtraPlayerController_OnObservedItemsChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnObservedBulletNumChanged
// (Final, Native, Public)

void ASTExtraPlayerController::OnObservedBulletNumChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnObservedBulletNumChanged");

	ASTExtraPlayerController_OnObservedBulletNumChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnMapMarkChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            TeamMateSerialNumber           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnMapMarkChangeDelegate__DelegateSignature(int TeamMateSerialNumber)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnMapMarkChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_OnMapMarkChangeDelegate__DelegateSignature_Params params;
	params.TeamMateSerialNumber = TeamMateSerialNumber;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLostConnection__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnLostConnection__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLostConnection__DelegateSignature");

	ASTExtraPlayerController_OnLostConnection__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLocalCharacterTemperatureChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          currentTP                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ratioHP                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnLocalCharacterTemperatureChangeDelegate__DelegateSignature(float currentTP, float ratioHP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLocalCharacterTemperatureChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_OnLocalCharacterTemperatureChangeDelegate__DelegateSignature_Params params;
	params.currentTP = currentTP;
	params.ratioHP = ratioHP;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLocalCharacterHPChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          currentHP                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ratioHP                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnLocalCharacterHPChangeDelegate__DelegateSignature(float currentHP, float ratioHP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnLocalCharacterHPChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_OnLocalCharacterHPChangeDelegate__DelegateSignature_Params params;
	params.currentHP = currentHP;
	params.ratioHP = ratioHP;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnLandOnGroundAfterJumpPlaneEnd
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerController::OnLandOnGroundAfterJumpPlaneEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnLandOnGroundAfterJumpPlaneEnd");

	ASTExtraPlayerController_OnLandOnGroundAfterJumpPlaneEnd_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnItemOperCount
// (Final, Native, Private)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// EBattleItemOperationType       operationType                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnItemOperCount(const struct FItemDefineID& DefineID, EBattleItemOperationType operationType, int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnItemOperCount");

	ASTExtraPlayerController_OnItemOperCount_Params params;
	params.DefineID = DefineID;
	params.operationType = operationType;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnItemOperation
// (Final, Native, Private)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// EBattleItemOperationType       operationType                  (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnItemOperation(const struct FItemDefineID& DefineID, EBattleItemOperationType operationType, unsigned char Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnItemOperation");

	ASTExtraPlayerController_OnItemOperation_Params params;
	params.DefineID = DefineID;
	params.operationType = operationType;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnInterruptAutoSprintCountDown__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnInterruptAutoSprintCountDown__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnInterruptAutoSprintCountDown__DelegateSignature");

	ASTExtraPlayerController_OnInterruptAutoSprintCountDown__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnGameStartDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnGameStartDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnGameStartDelegate__DelegateSignature");

	ASTExtraPlayerController_OnGameStartDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnGameStartCountDownDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          CountDownTime                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnGameStartCountDownDelegate__DelegateSignature(float CountDownTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnGameStartCountDownDelegate__DelegateSignature");

	ASTExtraPlayerController_OnGameStartCountDownDelegate__DelegateSignature_Params params;
	params.CountDownTime = CountDownTime;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnGameModeStateChanged
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerController::OnGameModeStateChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnGameModeStateChanged");

	ASTExtraPlayerController_OnGameModeStateChanged_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnFingerMove__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::OnFingerMove__DelegateSignature(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnFingerMove__DelegateSignature");

	ASTExtraPlayerController_OnFingerMove__DelegateSignature_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnExitGame__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnExitGame__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnExitGame__DelegateSignature");

	ASTExtraPlayerController_OnExitGame__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnEquipWeaponDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnEquipWeaponDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnEquipWeaponDelegate__DelegateSignature");

	ASTExtraPlayerController_OnEquipWeaponDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnEnterBattleResultStep
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnEnterBattleResultStep()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnEnterBattleResultStep");

	ASTExtraPlayerController_OnEnterBattleResultStep_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDropItemDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnDropItemDelegate__DelegateSignature(int ItemID, int Count, class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDropItemDelegate__DelegateSignature");

	ASTExtraPlayerController_OnDropItemDelegate__DelegateSignature_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDoubleClickCheckDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnDoubleClickCheckDelegate__DelegateSignature(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDoubleClickCheckDelegate__DelegateSignature");

	ASTExtraPlayerController_OnDoubleClickCheckDelegate__DelegateSignature_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDeathBoxSpawnedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// struct FTransform              SpawnTransform                 (Parm, IsPlainOldData)

void ASTExtraPlayerController::OnDeathBoxSpawnedDelegate__DelegateSignature(const struct FTransform& SpawnTransform)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDeathBoxSpawnedDelegate__DelegateSignature");

	ASTExtraPlayerController_OnDeathBoxSpawnedDelegate__DelegateSignature_Params params;
	params.SpawnTransform = SpawnTransform;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnDeadBoxExpand
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnDeadBoxExpand()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnDeadBoxExpand");

	ASTExtraPlayerController_OnDeadBoxExpand_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnDeadBoxCollapsed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           isCollpased                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnDeadBoxCollapsed(bool isCollpased)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnDeadBoxCollapsed");

	ASTExtraPlayerController_OnDeadBoxCollapsed_Params params;
	params.isCollpased = isCollpased;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDamageToOtherDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          damageToOther                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnDamageToOtherDelegate__DelegateSignature(float damageToOther)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnDamageToOtherDelegate__DelegateSignature");

	ASTExtraPlayerController_OnDamageToOtherDelegate__DelegateSignature_Params params;
	params.damageToOther = damageToOther;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterVehicleCheckVoiceTriggerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// class ASTExtraVehicleBase*     nowVehicle                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterVehicleCheckVoiceTriggerDelegate__DelegateSignature(class ASTExtraVehicleBase* nowVehicle, const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterVehicleCheckVoiceTriggerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterVehicleCheckVoiceTriggerDelegate__DelegateSignature_Params params;
	params.nowVehicle = nowVehicle;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterShotCheckVoiceTriggerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// class ASTExtraShootWeapon*     nowWeapon                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isslience                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterShotCheckVoiceTriggerDelegate__DelegateSignature(class ASTExtraShootWeapon* nowWeapon, const struct FVector& posVector, float showTime, bool isslience)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterShotCheckVoiceTriggerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterShotCheckVoiceTriggerDelegate__DelegateSignature_Params params;
	params.nowWeapon = nowWeapon;
	params.posVector = posVector;
	params.showTime = showTime;
	params.isslience = isslience;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.OnCharacterRecoveryHealthEvent
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::OnCharacterRecoveryHealthEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.OnCharacterRecoveryHealthEvent");

	ASTExtraPlayerController_OnCharacterRecoveryHealthEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterRecoveryHealth__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnCharacterRecoveryHealth__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterRecoveryHealth__DelegateSignature");

	ASTExtraPlayerController_OnCharacterRecoveryHealth__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterNearDeathOrRescueingOtherNotifyDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           IsNearDeath                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsRescueingOther               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterNearDeathOrRescueingOtherNotifyDelegate__DelegateSignature(bool IsNearDeath, bool IsRescueingOther)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterNearDeathOrRescueingOtherNotifyDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterNearDeathOrRescueingOtherNotifyDelegate__DelegateSignature_Params params;
	params.IsNearDeath = IsNearDeath;
	params.IsRescueingOther = IsRescueingOther;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterMoveCheckVoiceTriggerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// class ASTExtraBaseCharacter*   nowCharacter                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterMoveCheckVoiceTriggerDelegate__DelegateSignature(class ASTExtraBaseCharacter* nowCharacter, const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterMoveCheckVoiceTriggerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterMoveCheckVoiceTriggerDelegate__DelegateSignature_Params params;
	params.nowCharacter = nowCharacter;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterGlassCheckVoiceTriggerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasDefaults)
// Parameters:
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterGlassCheckVoiceTriggerDelegate__DelegateSignature(const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterGlassCheckVoiceTriggerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterGlassCheckVoiceTriggerDelegate__DelegateSignature_Params params;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterCheckVoiceTriggerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class AActor*                  nowActor                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          checkDis                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterCheckVoiceTriggerDelegate__DelegateSignature(class AActor* nowActor, float checkDis)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterCheckVoiceTriggerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterCheckVoiceTriggerDelegate__DelegateSignature_Params params;
	params.nowActor = nowActor;
	params.checkDis = checkDis;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterBreathChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// float                          currentBR                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ratioBR                        (Parm, ZeroConstructor, IsPlainOldData)
// class ACharacter*              OwnerCharacter                 (Parm, ZeroConstructor, IsPlainOldData)
// int                            HealthStatus                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnCharacterBreathChangeDelegate__DelegateSignature(float currentBR, float ratioBR, class ACharacter* OwnerCharacter, int HealthStatus)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnCharacterBreathChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_OnCharacterBreathChangeDelegate__DelegateSignature_Params params;
	params.currentBR = currentBR;
	params.ratioBR = ratioBR;
	params.OwnerCharacter = OwnerCharacter;
	params.HealthStatus = HealthStatus;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnChangeBattleOwnerDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnChangeBattleOwnerDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnChangeBattleOwnerDelegate__DelegateSignature");

	ASTExtraPlayerController_OnChangeBattleOwnerDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnBackpackMainSlot__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::OnBackpackMainSlot__DelegateSignature(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnBackpackMainSlot__DelegateSignature");

	ASTExtraPlayerController_OnBackpackMainSlot__DelegateSignature_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnAutoSprintActive__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::OnAutoSprintActive__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.OnAutoSprintActive__DelegateSignature");

	ASTExtraPlayerController_OnAutoSprintActive__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.On3DTouchForceChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraPlayerController::On3DTouchForceChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.On3DTouchForceChangeDelegate__DelegateSignature");

	ASTExtraPlayerController_On3DTouchForceChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ObserveWhoKilledMe
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::ObserveWhoKilledMe()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ObserveWhoKilledMe");

	ASTExtraPlayerController_ObserveWhoKilledMe_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ObserveCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 InPlayerName                   (Parm, ZeroConstructor)

void ASTExtraPlayerController::ObserveCharacter(const struct FString& InPlayerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ObserveCharacter");

	ASTExtraPlayerController_ObserveCharacter_Params params;
	params.InPlayerName = InPlayerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ObserveAirDropBox
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            boxId                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ObserveAirDropBox(int boxId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ObserveAirDropBox");

	ASTExtraPlayerController_ObserveAirDropBox_Params params;
	params.boxId = boxId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.NotifyInOutPickUpActorWrapperBP
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bIsIn                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::NotifyInOutPickUpActorWrapperBP(bool bIsIn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.NotifyInOutPickUpActorWrapperBP");

	ASTExtraPlayerController_NotifyInOutPickUpActorWrapperBP_Params params;
	params.bIsIn = bIsIn;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.MoveUp
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::MoveUp(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.MoveUp");

	ASTExtraPlayerController_MoveUp_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.MoveToAI
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::MoveToAI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.MoveToAI");

	ASTExtraPlayerController_MoveToAI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.MoveTo
// (Final, Exec, Native, Public)
// Parameters:
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Z                              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::MoveTo(float X, float Y, float Z)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.MoveTo");

	ASTExtraPlayerController_MoveTo_Params params;
	params.X = X;
	params.Y = Y;
	params.Z = Z;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ModifyTouchIndex
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ModifyTouchIndex(const struct FVector& Loc, TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ModifyTouchIndex");

	ASTExtraPlayerController_ModifyTouchIndex_Params params;
	params.Loc = Loc;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.MemberVoice
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            member                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Status                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::MemberVoice(int member, int Status)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.MemberVoice");

	ASTExtraPlayerController_MemberVoice_Params params;
	params.member = member;
	params.Status = Status;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.MarkStartFireFrame
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::MarkStartFireFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.MarkStartFireFrame");

	ASTExtraPlayerController_MarkStartFireFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.LocalProfileFootprint
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::LocalProfileFootprint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.LocalProfileFootprint");

	ASTExtraPlayerController_LocalProfileFootprint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.LocalGetGameStateReconnectInfo
// (Final, Native, Public)

void ASTExtraPlayerController::LocalGetGameStateReconnectInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.LocalGetGameStateReconnectInfo");

	ASTExtraPlayerController_LocalGetGameStateReconnectInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.LoadAllLand
// (Final, Exec, Native, Public)
// Parameters:
// bool                           bLoadAll                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::LoadAllLand(bool bLoadAll)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.LoadAllLand");

	ASTExtraPlayerController_LoadAllLand_Params params;
	params.bLoadAll = bLoadAll;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.LerpFPPCamera
// (Final, Native, Public)

void ASTExtraPlayerController::LerpFPPCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.LerpFPPCamera");

	ASTExtraPlayerController_LerpFPPCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.KillSomeOne
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 InPlayerName                   (Parm, ZeroConstructor)

void ASTExtraPlayerController::KillSomeOne(const struct FString& InPlayerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.KillSomeOne");

	ASTExtraPlayerController_KillSomeOne_Params params;
	params.InPlayerName = InPlayerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.KillAll
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::KillAll()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.KillAll");

	ASTExtraPlayerController_KillAll_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.Kill
// (Final, Exec, Native, Public)
// Parameters:
// int                            GivenNumber                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::Kill(int GivenNumber)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.Kill");

	ASTExtraPlayerController_Kill_Params params;
	params.GivenNumber = GivenNumber;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.JumpFromPlane
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::JumpFromPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.JumpFromPlane");

	ASTExtraPlayerController_JumpFromPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.JoystickTriggerSprint
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bIsSprint                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::JoystickTriggerSprint(bool bIsSprint)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.JoystickTriggerSprint");

	ASTExtraPlayerController_JoystickTriggerSprint_Params params;
	params.bIsSprint = bIsSprint;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsViewTarget
// (Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  pActor                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsViewTarget(class AActor* pActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsViewTarget");

	ASTExtraPlayerController_IsViewTarget_Params params;
	params.pActor = pActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsUse3DTouch
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsUse3DTouch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsUse3DTouch");

	ASTExtraPlayerController_IsUse3DTouch_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsStartInRightHalfScreen
// (Final, Native, Public, Const)
// Parameters:
// float                          BeginX                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          CurViewPortDPIScale            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsStartInRightHalfScreen(float BeginX, float CurViewPortDPIScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsStartInRightHalfScreen");

	ASTExtraPlayerController_IsStartInRightHalfScreen_Params params;
	params.BeginX = BeginX;
	params.CurViewPortDPIScale = CurViewPortDPIScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsSameTeam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   Other                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsSameTeam(class APawn* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsSameTeam");

	ASTExtraPlayerController_IsSameTeam_Params params;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsSameCamp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   Other                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsSameCamp(class APawn* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsSameCamp");

	ASTExtraPlayerController_IsSameCamp_Params params;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsReleasePosInAimBtnRange
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsReleasePosInAimBtnRange(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsReleasePosInAimBtnRange");

	ASTExtraPlayerController_IsReleasePosInAimBtnRange_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsMoveable
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsMoveable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsMoveable");

	ASTExtraPlayerController_IsMoveable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsLastBreathOrRescueingOther
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsLastBreathOrRescueingOther()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsLastBreathOrRescueingOther");

	ASTExtraPlayerController_IsLastBreathOrRescueingOther_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInPlane
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInPlane");

	ASTExtraPlayerController_IsInPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInParachuteOpen
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInParachuteOpen()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInParachuteOpen");

	ASTExtraPlayerController_IsInParachuteOpen_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInParachuteJump
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInParachuteJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInParachuteJump");

	ASTExtraPlayerController_IsInParachuteJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInParachute
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInParachute");

	ASTExtraPlayerController_IsInParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInInitial
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInInitial()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInInitial");

	ASTExtraPlayerController_IsInInitial_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInFreeCameraView
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInFreeCameraView()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInFreeCameraView");

	ASTExtraPlayerController_IsInFreeCameraView_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInFinish
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInFinish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInFinish");

	ASTExtraPlayerController_IsInFinish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInFight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInFight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInFight");

	ASTExtraPlayerController_IsInFight_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInDeathReplay
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInDeathReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInDeathReplay");

	ASTExtraPlayerController_IsInDeathReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsInDead
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsInDead()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsInDead");

	ASTExtraPlayerController_IsInDead_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsCanViewEnemy
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsCanViewEnemy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsCanViewEnemy");

	ASTExtraPlayerController_IsCanViewEnemy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsAllowActorTouchMove
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsAllowActorTouchMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsAllowActorTouchMove");

	ASTExtraPlayerController_IsAllowActorTouchMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.IsAGMPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::IsAGMPlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.IsAGMPlayer");

	ASTExtraPlayerController_IsAGMPlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InsertGrenadeIDToName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            GrenadeID                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   Name                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InsertGrenadeIDToName(int GrenadeID, const struct FName& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InsertGrenadeIDToName");

	ASTExtraPlayerController_InsertGrenadeIDToName_Params params;
	params.GrenadeID = GrenadeID;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InsertGrenadeIDInOrder
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            GrenadeID                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InsertGrenadeIDInOrder(int GrenadeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InsertGrenadeIDInOrder");

	ASTExtraPlayerController_InsertGrenadeIDInOrder_Params params;
	params.GrenadeID = GrenadeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InputTouchRepeat
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Location                       (ConstParm, Parm, IsPlainOldData)
// float                          force                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InputTouchRepeat(TEnumAsByte<ETouchIndex> FingerIndex, const struct FVector& Location, float force)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InputTouchRepeat");

	ASTExtraPlayerController_InputTouchRepeat_Params params;
	params.FingerIndex = FingerIndex;
	params.Location = Location;
	params.force = force;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitTaskDatas
// (Final, Native, Public)
// Parameters:
// uint32_t                       InPlayerKey                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InitTaskDatas(uint32_t InPlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitTaskDatas");

	ASTExtraPlayerController_InitTaskDatas_Params params;
	params.InPlayerKey = InPlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.InitTaskDataDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ext_info                       (Parm, ZeroConstructor)

void ASTExtraPlayerController::InitTaskDataDelegate__DelegateSignature(int TaskID, int process, const struct FString& ext_info)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.InitTaskDataDelegate__DelegateSignature");

	ASTExtraPlayerController_InitTaskDataDelegate__DelegateSignature_Params params;
	params.TaskID = TaskID;
	params.process = process;
	params.ext_info = ext_info;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitTaskData
// (Final, Native, Public)
// Parameters:
// int                            TaskID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ext_info                       (Parm, ZeroConstructor)

void ASTExtraPlayerController::InitTaskData(int TaskID, int process, const struct FString& ext_info)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitTaskData");

	ASTExtraPlayerController_InitTaskData_Params params;
	params.TaskID = TaskID;
	params.process = process;
	params.ext_info = ext_info;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitTaskComponent
// (Final, Native, Private)

void ASTExtraPlayerController::InitTaskComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitTaskComponent");

	ASTExtraPlayerController_InitTaskComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitNewbieComponent
// (Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// TArray<int>                    FinishedGuide                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<int>                    FinishedCounts                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// int                            PlayerLevel                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            PlayerExperienceType           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InitNewbieComponent(TArray<int> FinishedGuide, TArray<int> FinishedCounts, int PlayerLevel, int PlayerExperienceType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitNewbieComponent");

	ASTExtraPlayerController_InitNewbieComponent_Params params;
	params.FinishedGuide = FinishedGuide;
	params.FinishedCounts = FinishedCounts;
	params.PlayerLevel = PlayerLevel;
	params.PlayerExperienceType = PlayerExperienceType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitJoyStickAfterActivation
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerController::InitJoyStickAfterActivation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitJoyStickAfterActivation");

	ASTExtraPlayerController_InitJoyStickAfterActivation_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerController.InitCollectionDataDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurrentCount                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            TotalCount                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InitCollectionDataDelegate__DelegateSignature(int ItemID, int CurrentCount, int TotalCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerController.InitCollectionDataDelegate__DelegateSignature");

	ASTExtraPlayerController_InitCollectionDataDelegate__DelegateSignature_Params params;
	params.ItemID = ItemID;
	params.CurrentCount = CurrentCount;
	params.TotalCount = TotalCount;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.InitCollectionData
// (Final, Native, Public)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurrentCount                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            TotalCount                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::InitCollectionData(int ItemID, int CurrentCount, int TotalCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.InitCollectionData");

	ASTExtraPlayerController_InitCollectionData_Params params;
	params.ItemID = ItemID;
	params.CurrentCount = CurrentCount;
	params.TotalCount = TotalCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ImprisonmentTeammate
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// struct FString                 TeammateName                   (Parm, ZeroConstructor)

void ASTExtraPlayerController::ImprisonmentTeammate(const struct FString& TeammateName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ImprisonmentTeammate");

	ASTExtraPlayerController_ImprisonmentTeammate_Params params;
	params.TeammateName = TeammateName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleTogglePlayerListInOB
// (Final, Native, Public)

void ASTExtraPlayerController::HandleTogglePlayerListInOB()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleTogglePlayerListInOB");

	ASTExtraPlayerController_HandleTogglePlayerListInOB_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleToggleOBTeamList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           InShow                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::HandleToggleOBTeamList(bool InShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleToggleOBTeamList");

	ASTExtraPlayerController_HandleToggleOBTeamList_Params params;
	params.InShow = InShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleToggleMapInOB
// (Final, Native, Public)

void ASTExtraPlayerController::HandleToggleMapInOB()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleToggleMapInOB");

	ASTExtraPlayerController_HandleToggleMapInOB_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeammatePrev
// (Final, Native, Public)

void ASTExtraPlayerController::HandleSwitchToTeammatePrev()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeammatePrev");

	ASTExtraPlayerController_HandleSwitchToTeammatePrev_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeammateNext
// (Final, Native, Public)

void ASTExtraPlayerController::HandleSwitchToTeammateNext()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeammateNext");

	ASTExtraPlayerController_HandleSwitchToTeammateNext_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            InTeamID                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::HandleSwitchToTeam(int InTeamID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleSwitchToTeam");

	ASTExtraPlayerController_HandleSwitchToTeam_Params params;
	params.InTeamID = InTeamID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleLeaveFreeViewInOB
// (Final, Native, Public)

void ASTExtraPlayerController::HandleLeaveFreeViewInOB()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleLeaveFreeViewInOB");

	ASTExtraPlayerController_HandleLeaveFreeViewInOB_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleLandOnGroundEnd
// (Final, Native, Protected)

void ASTExtraPlayerController::HandleLandOnGroundEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleLandOnGroundEnd");

	ASTExtraPlayerController_HandleLandOnGroundEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleEnterFreeViewInOB
// (Final, Native, Public)

void ASTExtraPlayerController::HandleEnterFreeViewInOB()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleEnterFreeViewInOB");

	ASTExtraPlayerController_HandleEnterFreeViewInOB_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleClientHasReactivated
// (Final, Native, Protected)

void ASTExtraPlayerController::HandleClientHasReactivated()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleClientHasReactivated");

	ASTExtraPlayerController_HandleClientHasReactivated_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.HandleCameraModeChanged
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> NewMode                        (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   InCharacter                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::HandleCameraModeChanged(TEnumAsByte<EPlayerCameraMode> NewMode, class ASTExtraBaseCharacter* InCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.HandleCameraModeChanged");

	ASTExtraPlayerController_HandleCameraModeChanged_Params params;
	params.NewMode = NewMode;
	params.InCharacter = InCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GotoSpectating
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            TeammatePlayerid               (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GotoSpectating(int TeammatePlayerid)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GotoSpectating");

	ASTExtraPlayerController_GotoSpectating_Params params;
	params.TeammatePlayerid = TeammatePlayerid;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GotoFlying
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GotoFlying()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GotoFlying");

	ASTExtraPlayerController_GotoFlying_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMTeleport
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   Teleporter                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::GMTeleport(const struct FName& Teleporter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMTeleport");

	ASTExtraPlayerController_GMTeleport_Params params;
	params.Teleporter = Teleporter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolPoisonCircle
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMSetBoolPoisonCircle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolPoisonCircle");

	ASTExtraPlayerController_GMSetBoolPoisonCircle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAirDrop
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMSetBoolAirDrop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAirDrop");

	ASTExtraPlayerController_GMSetBoolAirDrop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAirAttack
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMSetBoolAirAttack()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAirAttack");

	ASTExtraPlayerController_GMSetBoolAirAttack_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAI
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMSetBoolAI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMSetBoolAI");

	ASTExtraPlayerController_GMSetBoolAI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMOpenWeather
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            OpenWeatherID                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::GMOpenWeather(int OpenWeatherID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMOpenWeather");

	ASTExtraPlayerController_GMOpenWeather_Params params;
	params.OpenWeatherID = OpenWeatherID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMEnableRandom
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMEnableRandom()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMEnableRandom");

	ASTExtraPlayerController_GMEnableRandom_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMEnableAllComponent
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMEnableAllComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMEnableAllComponent");

	ASTExtraPlayerController_GMEnableAllComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMDisableRandom
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMDisableRandom()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMDisableRandom");

	ASTExtraPlayerController_GMDisableRandom_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMDisableAllComponent
// (Final, Exec, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::GMDisableAllComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMDisableAllComponent");

	ASTExtraPlayerController_GMDisableAllComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GMCloseWeather
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            CloseWeatherID                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::GMCloseWeather(int CloseWeatherID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GMCloseWeather");

	ASTExtraPlayerController_GMCloseWeather_Params params;
	params.CloseWeatherID = CloseWeatherID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetWriteCircleDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetWriteCircleDistance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetWriteCircleDistance");

	ASTExtraPlayerController_GetWriteCircleDistance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetViewPortDPIScale
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerController::GetViewPortDPIScale()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetViewPortDPIScale");

	ASTExtraPlayerController_GetViewPortDPIScale_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetVehicleUserComp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UVehicleUserComponent*   ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UVehicleUserComponent* ASTExtraPlayerController::GetVehicleUserComp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetVehicleUserComp");

	ASTExtraPlayerController_GetVehicleUserComp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetUseMotionControlLog
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::GetUseMotionControlLog()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetUseMotionControlLog");

	ASTExtraPlayerController_GetUseMotionControlLog_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetUseMotionControlEnable
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::GetUseMotionControlEnable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetUseMotionControlEnable");

	ASTExtraPlayerController_GetUseMotionControlEnable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetTouchForce
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerController::GetTouchForce(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetTouchForce");

	ASTExtraPlayerController_GetTouchForce_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetThePlane
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ASTExtraPlayerController::GetThePlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetThePlane");

	ASTExtraPlayerController_GetThePlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetTargetedSpringArm
// (Final, Native, Public)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraPlayerController::GetTargetedSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetTargetedSpringArm");

	ASTExtraPlayerController_GetTargetedSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetStatTriangles
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetStatTriangles()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetStatTriangles");

	ASTExtraPlayerController_GetStatTriangles_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetStatMemory
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraPlayerController::GetStatMemory()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetStatMemory");

	ASTExtraPlayerController_GetStatMemory_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetStatDrawCalls
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetStatDrawCalls()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetStatDrawCalls");

	ASTExtraPlayerController_GetStatDrawCalls_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetSpecialAreaID
// (Final, Native, Public)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetSpecialAreaID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetSpecialAreaID");

	ASTExtraPlayerController_GetSpecialAreaID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetSensibilityRate
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           bIsMotionControl               (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator ASTExtraPlayerController::GetSensibilityRate(bool bIsMotionControl)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetSensibilityRate");

	ASTExtraPlayerController_GetSensibilityRate_Params params;
	params.bIsMotionControl = bIsMotionControl;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetPlayerInfoInOBByName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 InPlayerName                   (Parm, ZeroConstructor)
// struct FPlayerInfoInOB         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FPlayerInfoInOB ASTExtraPlayerController::GetPlayerInfoInOBByName(const struct FString& InPlayerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetPlayerInfoInOBByName");

	ASTExtraPlayerController_GetPlayerInfoInOBByName_Params params;
	params.InPlayerName = InPlayerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetPlayerCharacterSafety
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* ASTExtraPlayerController::GetPlayerCharacterSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetPlayerCharacterSafety");

	ASTExtraPlayerController_GetPlayerCharacterSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetNewestAirDropBoxPos
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraPlayerController::GetNewestAirDropBoxPos()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetNewestAirDropBoxPos");

	ASTExtraPlayerController_GetNewestAirDropBoxPos_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetNearPlayerList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FPlayerInfoInOB> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FPlayerInfoInOB> ASTExtraPlayerController::GetNearPlayerList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetNearPlayerList");

	ASTExtraPlayerController_GetNearPlayerList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetMurderUID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraPlayerController::GetMurderUID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetMurderUID");

	ASTExtraPlayerController_GetMurderUID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetMurderName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraPlayerController::GetMurderName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetMurderName");

	ASTExtraPlayerController_GetMurderName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetMurderIsAI
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::GetMurderIsAI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetMurderIsAI");

	ASTExtraPlayerController_GetMurderIsAI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetMultiItemFromItemList
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<int>                    ItemSpecifiedID                (Parm, ZeroConstructor)
// TArray<struct FBattleItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FBattleItemData> ASTExtraPlayerController::GetMultiItemFromItemList(TArray<int> ItemSpecifiedID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetMultiItemFromItemList");

	ASTExtraPlayerController_GetMultiItemFromItemList_Params params;
	params.ItemSpecifiedID = ItemSpecifiedID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetMaxTouchForceFinger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ETouchIndex> ASTExtraPlayerController::GetMaxTouchForceFinger()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetMaxTouchForceFinger");

	ASTExtraPlayerController_GetMaxTouchForceFinger_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetKillerTrackerTemplateForCauser
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class APawn*                   FatalDamageCauser              (Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UClass* ASTExtraPlayerController::GetKillerTrackerTemplateForCauser(class APawn* FatalDamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetKillerTrackerTemplateForCauser");

	ASTExtraPlayerController_GetKillerTrackerTemplateForCauser_Params params;
	params.FatalDamageCauser = FatalDamageCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetJoyStickVisualSize
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D ASTExtraPlayerController::GetJoyStickVisualSize()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetJoyStickVisualSize");

	ASTExtraPlayerController_GetJoyStickVisualSize_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetJoyStickCenter
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D ASTExtraPlayerController::GetJoyStickCenter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetJoyStickCenter");

	ASTExtraPlayerController_GetJoyStickCenter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetIsRespawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::GetIsRespawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetIsRespawn");

	ASTExtraPlayerController_GetIsRespawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetIsFreeCamera
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::GetIsFreeCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetIsFreeCamera");

	ASTExtraPlayerController_GetIsFreeCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetGameStateReconnectInfoOnServer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::GetGameStateReconnectInfoOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetGameStateReconnectInfoOnServer");

	ASTExtraPlayerController_GetGameStateReconnectInfoOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetGameScreenSize
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::GetGameScreenSize()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetGameScreenSize");

	ASTExtraPlayerController_GetGameScreenSize_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetFriendDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetFriendDistance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetFriendDistance");

	ASTExtraPlayerController_GetFriendDistance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetFocalLocation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraPlayerController::GetFocalLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetFocalLocation");

	ASTExtraPlayerController_GetFocalLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerState*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerState* ASTExtraPlayerController::GetCurPlayerState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerState");

	ASTExtraPlayerController_GetCurPlayerState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerId
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraPlayerController::GetCurPlayerId()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerId");

	ASTExtraPlayerController_GetCurPlayerId_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* ASTExtraPlayerController::GetCurPlayerCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurPlayerCharacter");

	ASTExtraPlayerController_GetCurPlayerCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurPawnLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraPlayerController::GetCurPawnLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurPawnLocation");

	ASTExtraPlayerController_GetCurPawnLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APawn* ASTExtraPlayerController::GetCurPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurPawn");

	ASTExtraPlayerController_GetCurPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetCurFPS
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerController::GetCurFPS()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetCurFPS");

	ASTExtraPlayerController_GetCurFPS_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetControlLookRotation
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator ASTExtraPlayerController::GetControlLookRotation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetControlLookRotation");

	ASTExtraPlayerController_GetControlLookRotation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetControlLookPoint
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// int                            LineTraceRange                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           HitTaget                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraPlayerController::GetControlLookPoint(int LineTraceRange, bool* HitTaget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetControlLookPoint");

	ASTExtraPlayerController_GetControlLookPoint_Params params;
	params.LineTraceRange = LineTraceRange;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (HitTaget != nullptr)
		*HitTaget = params.HitTaget;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetChatComponent
// (Final, Native, Public)
// Parameters:
// class UChatComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UChatComponent* ASTExtraPlayerController::GetChatComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetChatComponent");

	ASTExtraPlayerController_GetChatComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GetBackpackComponent
// (Final, Native, Public)
// Parameters:
// class UBackpackComponent*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBackpackComponent* ASTExtraPlayerController::GetBackpackComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GetBackpackComponent");

	ASTExtraPlayerController_GetBackpackComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GenerateAirDropData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            boxId                          (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FSearchedTombBoxAndWrapperListResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FSearchedTombBoxAndWrapperListResult> ASTExtraPlayerController::GenerateAirDropData(int boxId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GenerateAirDropData");

	ASTExtraPlayerController_GenerateAirDropData_Params params;
	params.boxId = boxId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GameModeGotoNextState
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::GameModeGotoNextState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GameModeGotoNextState");

	ASTExtraPlayerController_GameModeGotoNextState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.GameModeGotoFightingState
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::GameModeGotoFightingState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.GameModeGotoFightingState");

	ASTExtraPlayerController_GameModeGotoFightingState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.FreeCameraTouchMove
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::FreeCameraTouchMove(const struct FVector& Loc, TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.FreeCameraTouchMove");

	ASTExtraPlayerController_FreeCameraTouchMove_Params params;
	params.Loc = Loc;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ForceReleaseCurTouchMoveFinger
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::ForceReleaseCurTouchMoveFinger()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ForceReleaseCurTouchMoveFinger");

	ASTExtraPlayerController_ForceReleaseCurTouchMoveFinger_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.FireTakeDamagedEvent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 CauserLocation                 (Parm, IsPlainOldData)

void ASTExtraPlayerController::FireTakeDamagedEvent(const struct FVector& CauserLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.FireTakeDamagedEvent");

	ASTExtraPlayerController_FireTakeDamagedEvent_Params params;
	params.CauserLocation = CauserLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.FireOrGrenade
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::FireOrGrenade()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.FireOrGrenade");

	ASTExtraPlayerController_FireOrGrenade_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.Fight
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::Fight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.Fight");

	ASTExtraPlayerController_Fight_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ExitFreeCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsForceReset                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ExitFreeCamera(bool IsForceReset)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ExitFreeCamera");

	ASTExtraPlayerController_ExitFreeCamera_Params params;
	params.IsForceReset = IsForceReset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ExecDSCommand
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FString                 DSCommand                      (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::ExecDSCommand(const struct FString& DSCommand)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ExecDSCommand");

	ASTExtraPlayerController_ExecDSCommand_Params params;
	params.DSCommand = DSCommand;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EndTouchScreen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::EndTouchScreen(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EndTouchScreen");

	ASTExtraPlayerController_EndTouchScreen_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EndSpectatingWithoutDeadBox
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::EndSpectatingWithoutDeadBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EndSpectatingWithoutDeadBox");

	ASTExtraPlayerController_EndSpectatingWithoutDeadBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EndForceTouchFire
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::EndForceTouchFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EndForceTouchFire");

	ASTExtraPlayerController_EndForceTouchFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EnablePlayerInHouse
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bIsIn                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::EnablePlayerInHouse(bool bIsIn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EnablePlayerInHouse");

	ASTExtraPlayerController_EnablePlayerInHouse_Params params;
	params.bIsIn = bIsIn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EnableMyLandscapeDraw
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::EnableMyLandscapeDraw()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EnableMyLandscapeDraw");

	ASTExtraPlayerController_EnableMyLandscapeDraw_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.EmulatorSettingFireMode
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::EmulatorSettingFireMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.EmulatorSettingFireMode");

	ASTExtraPlayerController_EmulatorSettingFireMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DoUITouchMove
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void ASTExtraPlayerController::DoUITouchMove(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DoUITouchMove");

	ASTExtraPlayerController_DoUITouchMove_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DoubleClickCancel
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DoubleClickCancel(TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DoubleClickCancel");

	ASTExtraPlayerController_DoubleClickCancel_Params params;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DoTouchMove
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Yaw                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          Pitch                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DoTouchMove(float Yaw, float Pitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DoTouchMove");

	ASTExtraPlayerController_DoTouchMove_Params params;
	params.Yaw = Yaw;
	params.Pitch = Pitch;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipWithMsgIDAndString
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Param1                         (Parm, ZeroConstructor)
// struct FString                 Param2                         (Parm, ZeroConstructor)

void ASTExtraPlayerController::DisplayGameTipWithMsgIDAndString(int ID, const struct FString& Param1, const struct FString& Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipWithMsgIDAndString");

	ASTExtraPlayerController_DisplayGameTipWithMsgIDAndString_Params params;
	params.ID = ID;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipWithMsgID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DisplayGameTipWithMsgID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipWithMsgID");

	ASTExtraPlayerController_DisplayGameTipWithMsgID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipForLowFPSWarning
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Param1                         (Parm, ZeroConstructor)
// struct FString                 Param2                         (Parm, ZeroConstructor)

void ASTExtraPlayerController::DisplayGameTipForLowFPSWarning(int ID, const struct FString& Param1, const struct FString& Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DisplayGameTipForLowFPSWarning");

	ASTExtraPlayerController_DisplayGameTipForLowFPSWarning_Params params;
	params.ID = ID;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerReconnectedEvent
// (Final, Native, Public)

void ASTExtraPlayerController::DispatchPlayerReconnectedEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerReconnectedEvent");

	ASTExtraPlayerController_DispatchPlayerReconnectedEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerLostEvent
// (Final, Native, Public)

void ASTExtraPlayerController::DispatchPlayerLostEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerLostEvent");

	ASTExtraPlayerController_DispatchPlayerLostEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerExitEvent
// (Final, Native, Public)

void ASTExtraPlayerController::DispatchPlayerExitEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DispatchPlayerExitEvent");

	ASTExtraPlayerController_DispatchPlayerExitEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DisableSequencePlayer
// (Exec, Event, Public, BlueprintEvent)

void ASTExtraPlayerController::DisableSequencePlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DisableSequencePlayer");

	ASTExtraPlayerController_DisableSequencePlayer_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DisableMyLandscapeDraw
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::DisableMyLandscapeDraw()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DisableMyLandscapeDraw");

	ASTExtraPlayerController_DisableMyLandscapeDraw_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DelayForceExitFreeCamera
// (Final, Native, Public)

void ASTExtraPlayerController::DelayForceExitFreeCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DelayForceExitFreeCamera");

	ASTExtraPlayerController_DelayForceExitFreeCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DebugWorldPlayerAvatarInfo
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::DebugWorldPlayerAvatarInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DebugWorldPlayerAvatarInfo");

	ASTExtraPlayerController_DebugWorldPlayerAvatarInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DebugSetUIVisibility
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           bUIVisibility                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DebugSetUIVisibility(bool bUIVisibility)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DebugSetUIVisibility");

	ASTExtraPlayerController_DebugSetUIVisibility_Params params;
	params.bUIVisibility = bUIVisibility;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearShotWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          disRate                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DealGetAllNearShotWeapon(float disRate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearShotWeapon");

	ASTExtraPlayerController_DealGetAllNearShotWeapon_Params params;
	params.disRate = disRate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearMoveVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          checkDis                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          minSpeed                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DealGetAllNearMoveVehicle(float checkDis, float minSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearMoveVehicle");

	ASTExtraPlayerController_DealGetAllNearMoveVehicle_Params params;
	params.checkDis = checkDis;
	params.minSpeed = minSpeed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearMoveCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          checkDis                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DealGetAllNearMoveCharacter(float checkDis)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DealGetAllNearMoveCharacter");

	ASTExtraPlayerController_DealGetAllNearMoveCharacter_Params params;
	params.checkDis = checkDis;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.DeactiveTaskTrigger
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> ConditionType                  (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::DeactiveTaskTrigger(TEnumAsByte<ETaskConditionType> ConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.DeactiveTaskTrigger");

	ASTExtraPlayerController_DeactiveTaskTrigger_Params params;
	params.ConditionType = ConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CorrectVehicleState
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ServerLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ServerLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ServerRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ServerAngularVelocity          (ConstParm, Parm, ReferenceParm)
// bool                           bIsSnap                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::CorrectVehicleState(int InCorrectionId, const struct FVector_NetQuantize100& ServerLocation, const struct FVector_NetQuantize100& ServerLinearVelocity, const struct FVector_NetQuantizeNormal& ServerRotator, const struct FVector_NetQuantize100& ServerAngularVelocity, bool bIsSnap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CorrectVehicleState");

	ASTExtraPlayerController_CorrectVehicleState_Params params;
	params.InCorrectionId = InCorrectionId;
	params.ServerLocation = ServerLocation;
	params.ServerLinearVelocity = ServerLinearVelocity;
	params.ServerRotator = ServerRotator;
	params.ServerAngularVelocity = ServerAngularVelocity;
	params.bIsSnap = bIsSnap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CloseCostedUI
// (Final, Exec, Native, Public)

void ASTExtraPlayerController::CloseCostedUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CloseCostedUI");

	ASTExtraPlayerController_CloseCostedUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientStartOnlineGame
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientStartOnlineGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientStartOnlineGame");

	ASTExtraPlayerController_ClientStartOnlineGame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientSetTotalPlayers
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// TArray<struct FPlayerStaticInfoInOB> InPlayerStaticInfoList         (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// TArray<struct FPlayerBaseInfoInOB> InTotalPlayers                 (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerController::ClientSetTotalPlayers(TArray<struct FPlayerStaticInfoInOB> InPlayerStaticInfoList, TArray<struct FPlayerBaseInfoInOB> InTotalPlayers)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientSetTotalPlayers");

	ASTExtraPlayerController_ClientSetTotalPlayers_Params params;
	params.InPlayerStaticInfoList = InPlayerStaticInfoList;
	params.InTotalPlayers = InTotalPlayers;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientSetAIPosToTarget
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 startPos                       (Parm, IsPlainOldData)
// struct FVector                 targetPos                      (Parm, IsPlainOldData)

void ASTExtraPlayerController::ClientSetAIPosToTarget(const struct FVector& startPos, const struct FVector& targetPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientSetAIPosToTarget");

	ASTExtraPlayerController_ClientSetAIPosToTarget_Params params;
	params.startPos = startPos;
	params.targetPos = targetPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientSetAIPos
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// uint32_t                       keyID                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 pos                            (Parm, IsPlainOldData)
// bool                           isStart                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientSetAIPos(uint32_t keyID, const struct FVector& pos, bool isStart)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientSetAIPos");

	ASTExtraPlayerController_ClientSetAIPos_Params params;
	params.keyID = keyID;
	params.pos = pos;
	params.isStart = isStart;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientSendRoundEndEvent
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// bool                           bIsWinner                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            ExpendedTimeInSeconds          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientSendRoundEndEvent(bool bIsWinner, int ExpendedTimeInSeconds)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientSendRoundEndEvent");

	ASTExtraPlayerController_ClientSendRoundEndEvent_Params params;
	params.bIsWinner = bIsWinner;
	params.ExpendedTimeInSeconds = ExpendedTimeInSeconds;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientRefreshOBPlayerShowWeaponInfo
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientRefreshOBPlayerShowWeaponInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientRefreshOBPlayerShowWeaponInfo");

	ASTExtraPlayerController_ClientRefreshOBPlayerShowWeaponInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientQuitViewEnemy
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientQuitViewEnemy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientQuitViewEnemy");

	ASTExtraPlayerController_ClientQuitViewEnemy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientOnHurt
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientOnHurt()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientOnHurt");

	ASTExtraPlayerController_ClientOnHurt_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientOnDamageToOther
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// float                          _DamageToOther                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientOnDamageToOther(float _DamageToOther)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientOnDamageToOther");

	ASTExtraPlayerController_ClientOnDamageToOther_Params params;
	params._DamageToOther = _DamageToOther;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientObserveCharacter
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// uint32_t                       InPlayerKey                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsOnPlane                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientObserveCharacter(uint32_t InPlayerKey, bool IsOnPlane)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientObserveCharacter");

	ASTExtraPlayerController_ClientObserveCharacter_Params params;
	params.InPlayerKey = InPlayerKey;
	params.IsOnPlane = IsOnPlane;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientHearSound
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// int                            AkEventID                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 AkLocation                     (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::ClientHearSound(int AkEventID, const struct FVector& AkLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientHearSound");

	ASTExtraPlayerController_ClientHearSound_Params params;
	params.AkEventID = AkEventID;
	params.AkLocation = AkLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientHandleMsg
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// EMsgType                       Msg                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientHandleMsg(EMsgType Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientHandleMsg");

	ASTExtraPlayerController_ClientHandleMsg_Params params;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientGameStarted
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientGameStarted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientGameStarted");

	ASTExtraPlayerController_ClientGameStarted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientFriendBattleEnd
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientFriendBattleEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientFriendBattleEnd");

	ASTExtraPlayerController_ClientFriendBattleEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientEnterViewBox
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            boxId                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientEnterViewBox(int boxId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientEnterViewBox");

	ASTExtraPlayerController_ClientEnterViewBox_Params params;
	params.boxId = boxId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientEndOnlineGame
// (Net, NetReliable, Native, Event, Public, NetClient)

void ASTExtraPlayerController::ClientEndOnlineGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientEndOnlineGame");

	ASTExtraPlayerController_ClientEndOnlineGame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgIDAndStringReliable
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Param1                         (Parm, ZeroConstructor)
// struct FString                 Param2                         (Parm, ZeroConstructor)

void ASTExtraPlayerController::ClientDisplayGameTipWithMsgIDAndStringReliable(int ID, const struct FString& Param1, const struct FString& Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgIDAndStringReliable");

	ASTExtraPlayerController_ClientDisplayGameTipWithMsgIDAndStringReliable_Params params;
	params.ID = ID;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgIDAndString
// (Net, Native, Event, Public, NetClient)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Param1                         (Parm, ZeroConstructor)
// struct FString                 Param2                         (Parm, ZeroConstructor)

void ASTExtraPlayerController::ClientDisplayGameTipWithMsgIDAndString(int ID, const struct FString& Param1, const struct FString& Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgIDAndString");

	ASTExtraPlayerController_ClientDisplayGameTipWithMsgIDAndString_Params params;
	params.ID = ID;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgID
// (Net, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientDisplayGameTipWithMsgID(int ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientDisplayGameTipWithMsgID");

	ASTExtraPlayerController_ClientDisplayGameTipWithMsgID_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClientChangeStatePC
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// EStateType                     TargetStateType                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ClientChangeStatePC(EStateType TargetStateType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClientChangeStatePC");

	ASTExtraPlayerController_ClientChangeStatePC_Params params;
	params.TargetStateType = TargetStateType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ClampFreeCamIconOffset
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FGeometry               MyGeometry                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D ASTExtraPlayerController::ClampFreeCamIconOffset(const struct FGeometry& MyGeometry)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ClampFreeCamIconOffset");

	ASTExtraPlayerController_ClampFreeCamIconOffset_Params params;
	params.MyGeometry = MyGeometry;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ChangeSpectatorStateToFreeView
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::ChangeSpectatorStateToFreeView()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ChangeSpectatorStateToFreeView");

	ASTExtraPlayerController_ChangeSpectatorStateToFreeView_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CanSeeAllUI
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUIVisibility                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::CanSeeAllUI(bool bUIVisibility)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CanSeeAllUI");

	ASTExtraPlayerController_CanSeeAllUI_Params params;
	params.bUIVisibility = bUIVisibility;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CallTeamMateStateChanged
// (Final, Native, Public, HasDefaults)
// Parameters:
// class ASTExtraPlayerState*     STPlayerState                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Location                       (Parm, IsPlainOldData)
// struct FRotator                Rotation                       (Parm, IsPlainOldData)
// float                          Health                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            VoiceID                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::CallTeamMateStateChanged(class ASTExtraPlayerState* STPlayerState, const struct FVector& Location, const struct FRotator& Rotation, float Health, int VoiceID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CallTeamMateStateChanged");

	ASTExtraPlayerController_CallTeamMateStateChanged_Params params;
	params.STPlayerState = STPlayerState;
	params.Location = Location;
	params.Rotation = Rotation;
	params.Health = Health;
	params.VoiceID = VoiceID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CallShowTouchInterface
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           InShow                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::CallShowTouchInterface(bool InShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CallShowTouchInterface");

	ASTExtraPlayerController_CallShowTouchInterface_Params params;
	params.InShow = InShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CalInputFromRotaionRate
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// float                          OutPitch                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          OutYaw                         (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           bIsAddPitch                    (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           bIsAddYaw                      (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// struct FVector                 CurMotionData                  (Parm, IsPlainOldData)
// float                          PitchReverce                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionTouchRate_Pitch          (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionTouchAimRate_Pitch       (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionRate_Pitch               (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionAimRate_Pitch            (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionTouchRate_Yaw            (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionTouchAimRate_Yaw         (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionRate_Yaw                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionAimRate_Yaw              (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionRate_Pitch_Threshold     (Parm, ZeroConstructor, IsPlainOldData)
// float                          MotionRate_Yaw_Threshold       (Parm, ZeroConstructor, IsPlainOldData)
// float                          Left                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          Right                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bLandScapeOrientation          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::CalInputFromRotaionRate(float MotionAimRate_Pitch, float Right, float Left, float MotionRate_Yaw_Threshold, const struct FVector& CurMotionData, float PitchReverce, float MotionTouchRate_Pitch, float MotionTouchAimRate_Pitch, float MotionRate_Pitch, bool bLandScapeOrientation, float MotionTouchRate_Yaw, float MotionTouchAimRate_Yaw, float MotionRate_Yaw, float MotionAimRate_Yaw, float MotionRate_Pitch_Threshold, bool* bIsAddYaw, bool* bIsAddPitch, float* OutYaw, float* OutPitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CalInputFromRotaionRate");

	ASTExtraPlayerController_CalInputFromRotaionRate_Params params;
	params.CurMotionData = CurMotionData;
	params.PitchReverce = PitchReverce;
	params.MotionTouchRate_Pitch = MotionTouchRate_Pitch;
	params.MotionTouchAimRate_Pitch = MotionTouchAimRate_Pitch;
	params.MotionRate_Pitch = MotionRate_Pitch;
	params.MotionAimRate_Pitch = MotionAimRate_Pitch;
	params.MotionTouchRate_Yaw = MotionTouchRate_Yaw;
	params.MotionTouchAimRate_Yaw = MotionTouchAimRate_Yaw;
	params.MotionRate_Yaw = MotionRate_Yaw;
	params.MotionAimRate_Yaw = MotionAimRate_Yaw;
	params.MotionRate_Pitch_Threshold = MotionRate_Pitch_Threshold;
	params.MotionRate_Yaw_Threshold = MotionRate_Yaw_Threshold;
	params.Left = Left;
	params.Right = Right;
	params.bLandScapeOrientation = bLandScapeOrientation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutPitch != nullptr)
		*OutPitch = params.OutPitch;
	if (OutYaw != nullptr)
		*OutYaw = params.OutYaw;
	if (bIsAddPitch != nullptr)
		*bIsAddPitch = params.bIsAddPitch;
	if (bIsAddYaw != nullptr)
		*bIsAddYaw = params.bIsAddYaw;
}


// Function ShadowTrackerExtra.STExtraPlayerController.CalcAttactBtnPos
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                          locX                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          locY                           (Parm, ZeroConstructor, IsPlainOldData)
// float                          SizeX                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          SizeY                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D ASTExtraPlayerController::CalcAttactBtnPos(float locX, float locY, float SizeX, float SizeY)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.CalcAttactBtnPos");

	ASTExtraPlayerController_CalcAttactBtnPos_Params params;
	params.locX = locX;
	params.locY = locY;
	params.SizeX = SizeX;
	params.SizeY = SizeY;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.C2S_RequestSkillPrompt
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraPlayerController::C2S_RequestSkillPrompt()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.C2S_RequestSkillPrompt");

	ASTExtraPlayerController_C2S_RequestSkillPrompt_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.C2S_RequestBeingRescuedRemainingTime
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void ASTExtraPlayerController::C2S_RequestBeingRescuedRemainingTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.C2S_RequestBeingRescuedRemainingTime");

	ASTExtraPlayerController_C2S_RequestBeingRescuedRemainingTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BroadcastFatalDamageToClient
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FString                 causerName                     (Parm, ZeroConstructor)
// struct FString                 victimName                     (Parm, ZeroConstructor)
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageWeaponSkin               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadshot                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            ResultHealthStatus             (Parm, ZeroConstructor, IsPlainOldData)
// int                            Relationship                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            PreviousHealthStatus           (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 realKillerName                 (Parm, ZeroConstructor)
// int                            realKillerNewKillNum           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsCauserMonster                (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       causerKey                      (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       victimKey                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            causerAnchorPlatformResID      (Parm, ZeroConstructor, IsPlainOldData)
// int                            causerAnchorPlatformColorID    (Parm, ZeroConstructor, IsPlainOldData)
// int                            victimAnchorPlatformResID      (Parm, ZeroConstructor, IsPlainOldData)
// int                            victimAnchorPlatformColorID    (Parm, ZeroConstructor, IsPlainOldData)
// int                            realKillerAnchorPlatformResID  (Parm, ZeroConstructor, IsPlainOldData)
// int                            realKillerAnchorPlatformColorID (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 CauseUID                       (Parm, ZeroConstructor)
// struct FString                 VictimUID                      (Parm, ZeroConstructor)

void ASTExtraPlayerController::BroadcastFatalDamageToClient(const struct FString& causerName, const struct FString& victimName, int DamageType, int AdditionalParam, int DamageWeaponSkin, bool IsHeadshot, int ResultHealthStatus, int Relationship, int PreviousHealthStatus, const struct FString& realKillerName, int realKillerNewKillNum, bool IsCauserMonster, uint32_t causerKey, uint32_t victimKey, int causerAnchorPlatformResID, int causerAnchorPlatformColorID, int victimAnchorPlatformResID, int victimAnchorPlatformColorID, int realKillerAnchorPlatformResID, int realKillerAnchorPlatformColorID, const struct FString& CauseUID, const struct FString& VictimUID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BroadcastFatalDamageToClient");

	ASTExtraPlayerController_BroadcastFatalDamageToClient_Params params;
	params.causerName = causerName;
	params.victimName = victimName;
	params.DamageType = DamageType;
	params.AdditionalParam = AdditionalParam;
	params.DamageWeaponSkin = DamageWeaponSkin;
	params.IsHeadshot = IsHeadshot;
	params.ResultHealthStatus = ResultHealthStatus;
	params.Relationship = Relationship;
	params.PreviousHealthStatus = PreviousHealthStatus;
	params.realKillerName = realKillerName;
	params.realKillerNewKillNum = realKillerNewKillNum;
	params.IsCauserMonster = IsCauserMonster;
	params.causerKey = causerKey;
	params.victimKey = victimKey;
	params.causerAnchorPlatformResID = causerAnchorPlatformResID;
	params.causerAnchorPlatformColorID = causerAnchorPlatformColorID;
	params.victimAnchorPlatformResID = victimAnchorPlatformResID;
	params.victimAnchorPlatformColorID = victimAnchorPlatformColorID;
	params.realKillerAnchorPlatformResID = realKillerAnchorPlatformResID;
	params.realKillerAnchorPlatformColorID = realKillerAnchorPlatformColorID;
	params.CauseUID = CauseUID;
	params.VictimUID = VictimUID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BroadcastClientsSpawnExplosionEffect
// (Net, Native, Event, NetMulticast, Public, HasDefaults, NetValidate)
// Parameters:
// class UClass*                  Template                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FTransform              Trans                          (Parm, IsPlainOldData)
// class AActor*                  ActorOwner                     (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   InstigatorPawn                 (Parm, ZeroConstructor, IsPlainOldData)
// ESpawnActorCollisionHandlingMethod method                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::BroadcastClientsSpawnExplosionEffect(class UClass* Template, const struct FTransform& Trans, class AActor* ActorOwner, class APawn* InstigatorPawn, ESpawnActorCollisionHandlingMethod method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BroadcastClientsSpawnExplosionEffect");

	ASTExtraPlayerController_BroadcastClientsSpawnExplosionEffect_Params params;
	params.Template = Template;
	params.Trans = Trans;
	params.ActorOwner = ActorOwner;
	params.InstigatorPawn = InstigatorPawn;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BPGetIsAndroidSimulator
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::BPGetIsAndroidSimulator()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BPGetIsAndroidSimulator");

	ASTExtraPlayerController_BPGetIsAndroidSimulator_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BP_OceanSideDetected
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                 OceansideLocation              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           bDetectedRiver                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::BP_OceanSideDetected(const struct FVector& OceansideLocation, bool bDetectedRiver)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BP_OceanSideDetected");

	ASTExtraPlayerController_BP_OceanSideDetected_Params params;
	params.OceansideLocation = OceansideLocation;
	params.bDetectedRiver = bDetectedRiver;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BleTurnInput
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               DeltaDirection                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// TEnumAsByte<EInputEvent>       EventType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::BleTurnInput(const struct FVector2D& DeltaDirection, TEnumAsByte<EInputEvent> EventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BleTurnInput");

	ASTExtraPlayerController_BleTurnInput_Params params;
	params.DeltaDirection = DeltaDirection;
	params.EventType = EventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BeginTouchScreen
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (Parm, IsPlainOldData)
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::BeginTouchScreen(const struct FVector& Loc, TEnumAsByte<ETouchIndex> FingerIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BeginTouchScreen");

	ASTExtraPlayerController_BeginTouchScreen_Params params;
	params.Loc = Loc;
	params.FingerIndex = FingerIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BeginSpectatingWithoutDeadBox
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerController::BeginSpectatingWithoutDeadBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BeginSpectatingWithoutDeadBox");

	ASTExtraPlayerController_BeginSpectatingWithoutDeadBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.BackToGameDataRefresh
// (Final, Native, Private)

void ASTExtraPlayerController::BackToGameDataRefresh()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.BackToGameDataRefresh");

	ASTExtraPlayerController_BackToGameDataRefresh_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.AutoSelectViewTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerController::AutoSelectViewTarget()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.AutoSelectViewTarget");

	ASTExtraPlayerController_AutoSelectViewTarget_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerController.AddTouchMoveFinger
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETouchIndex>       FingerIndex                    (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Priority                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 TouchLoc                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraPlayerController::AddTouchMoveFinger(TEnumAsByte<ETouchIndex> FingerIndex, unsigned char Priority, const struct FVector& TouchLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.AddTouchMoveFinger");

	ASTExtraPlayerController_AddTouchMoveFinger_Params params;
	params.FingerIndex = FingerIndex;
	params.Priority = Priority;
	params.TouchLoc = TouchLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.AddItem
// (Final, Exec, Native, Public)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::AddItem(int ID, int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.AddItem");

	ASTExtraPlayerController_AddItem_Params params;
	params.ID = ID;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ActiveTaskTrigger
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> ConditionType                  (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ActiveTaskTrigger(TEnumAsByte<ETaskConditionType> ConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ActiveTaskTrigger");

	ASTExtraPlayerController_ActiveTaskTrigger_Params params;
	params.ConditionType = ConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerController.ActivateTouchInterface
// (Native, Public, BlueprintCallable)
// Parameters:
// class UTouchInterface*         NewTouchInterface              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerController::ActivateTouchInterface(class UTouchInterface* NewTouchInterface)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerController.ActivateTouchInterface");

	ASTExtraPlayerController_ActivateTouchInterface_Params params;
	params.NewTouchInterface = NewTouchInterface;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.YBTimerSkill
// (Final, Native, Public)

void UGMCheatManager::YBTimerSkill()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.YBTimerSkill");

	UGMCheatManager_YBTimerSkill_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.YBSkill
// (Final, Exec, Native, Public)
// Parameters:
// int                            SkillIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          Timer                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::YBSkill(int SkillIndex, float Timer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.YBSkill");

	UGMCheatManager_YBSkill_Params params;
	params.SkillIndex = SkillIndex;
	params.Timer = Timer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.YBIgnorePlayer
// (Final, Exec, Native, Public)

void UGMCheatManager::YBIgnorePlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.YBIgnorePlayer");

	UGMCheatManager_YBIgnorePlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ToggleSpringMode
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::ToggleSpringMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ToggleSpringMode");

	UGMCheatManager_ToggleSpringMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ToggleSpringDebug
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::ToggleSpringDebug()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ToggleSpringDebug");

	UGMCheatManager_ToggleSpringDebug_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ToggleShootVertify
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::ToggleShootVertify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ToggleShootVertify");

	UGMCheatManager_ToggleShootVertify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.TogglePawnInfo
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::TogglePawnInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.TogglePawnInfo");

	UGMCheatManager_TogglePawnInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.TestWeaponAttachment
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEquip                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::TestWeaponAttachment(bool bEquip)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.TestWeaponAttachment");

	UGMCheatManager_TestWeaponAttachment_Params params;
	params.bEquip = bEquip;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.TestLineTrace
// (Final, Exec, Native, Public)
// Parameters:
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Z                              (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::TestLineTrace(float X, float Y, float Z)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.TestLineTrace");

	UGMCheatManager_TestLineTrace_Params params;
	params.X = X;
	params.Y = Y;
	params.Z = Z;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.TestGameplayDataRecord
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            UID                            (Parm, ZeroConstructor, IsPlainOldData)
// int                            RecordType                     (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::TestGameplayDataRecord(int UID, int RecordType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.TestGameplayDataRecord");

	UGMCheatManager_TestGameplayDataRecord_Params params;
	params.UID = UID;
	params.RecordType = RecordType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.TeleportTo
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// float                          X                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Y                              (Parm, ZeroConstructor, IsPlainOldData)
// float                          Z                              (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::TeleportTo(float X, float Y, float Z)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.TeleportTo");

	UGMCheatManager_TeleportTo_Params params;
	params.X = X;
	params.Y = Y;
	params.Z = Z;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.StopBigYearBeast
// (Final, Exec, Native, Public)

void UGMCheatManager::StopBigYearBeast()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.StopBigYearBeast");

	UGMCheatManager_StopBigYearBeast_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.StatVehicle
// (Final, Exec, Native, Public)

void UGMCheatManager::StatVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.StatVehicle");

	UGMCheatManager_StatVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.StartMainTriggerClock
// (Final, Exec, Native, Public)

void UGMCheatManager::StartMainTriggerClock()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.StartMainTriggerClock");

	UGMCheatManager_StartMainTriggerClock_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SpawnLevelDirector
// (Final, Exec, Native, Public)

void UGMCheatManager::SpawnLevelDirector()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SpawnLevelDirector");

	UGMCheatManager_SpawnLevelDirector_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SpawnFakePlayer
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SpawnFakePlayer(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SpawnFakePlayer");

	UGMCheatManager_SpawnFakePlayer_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SpawnBotForTest
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SpawnBotForTest(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SpawnBotForTest");

	UGMCheatManager_SpawnBotForTest_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SpawnBigYearBeast
// (Final, Exec, Native, Public)
// Parameters:
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SpawnBigYearBeast(int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SpawnBigYearBeast");

	UGMCheatManager_SpawnBigYearBeast_Params params;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ShowResultAvatarInfo
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::ShowResultAvatarInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ShowResultAvatarInfo");

	UGMCheatManager_ShowResultAvatarInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ShowParachuteJumpDebugLine
// (Final, Exec, Native, Public)
// Parameters:
// bool                           IsShow                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::ShowParachuteJumpDebugLine(bool IsShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ShowParachuteJumpDebugLine");

	UGMCheatManager_ShowParachuteJumpDebugLine_Params params;
	params.IsShow = IsShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ShowNearbyCharHP
// (Final, Exec, Native, Public, Const)
// Parameters:
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::ShowNearbyCharHP(float Radius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ShowNearbyCharHP");

	UGMCheatManager_ShowNearbyCharHP_Params params;
	params.Radius = Radius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ShowBigYearBeastData
// (Final, Exec, Native, Public)

void UGMCheatManager::ShowBigYearBeastData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ShowBigYearBeastData");

	UGMCheatManager_ShowBigYearBeastData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetViewFPP
// (Final, Exec, Native, Public)
// Parameters:
// bool                           IsFPP                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetViewFPP(bool IsFPP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetViewFPP");

	UGMCheatManager_SetViewFPP_Params params;
	params.IsFPP = IsFPP;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetTouchMoveLog
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetTouchMoveLog(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetTouchMoveLog");

	UGMCheatManager_SetTouchMoveLog_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetTouchMoveDelay
// (Final, Exec, Native, Public)
// Parameters:
// int                            DelayFrame                     (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetTouchMoveDelay(int DelayFrame)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetTouchMoveDelay");

	UGMCheatManager_SetTouchMoveDelay_Params params;
	params.DelayFrame = DelayFrame;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetSkillDup
// (Final, Exec, Native, Public)
// Parameters:
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetSkillDup(int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetSkillDup");

	UGMCheatManager_SetSkillDup_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetSequencerPlaybackPosition
// (Final, Exec, Native, Public)
// Parameters:
// float                          Percent                        (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetSequencerPlaybackPosition(float Percent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetSequencerPlaybackPosition");

	UGMCheatManager_SetSequencerPlaybackPosition_Params params;
	params.Percent = Percent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetRateScore
// (Final, Exec, Native, Public)
// Parameters:
// float                          RankScore                      (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetRateScore(float RankScore)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetRateScore");

	UGMCheatManager_SetRateScore_Params params;
	params.RankScore = RankScore;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetNeckUp
// (Final, Exec, Native, Public)
// Parameters:
// float                          UpAngle                        (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetNeckUp(float UpAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetNeckUp");

	UGMCheatManager_SetNeckUp_Params params;
	params.UpAngle = UpAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetNeckSpeed
// (Final, Exec, Native, Public)
// Parameters:
// float                          Speed                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetNeckSpeed(float Speed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetNeckSpeed");

	UGMCheatManager_SetNeckSpeed_Params params;
	params.Speed = Speed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetNeckRight
// (Final, Exec, Native, Public)
// Parameters:
// float                          RightAngle                     (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetNeckRight(float RightAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetNeckRight");

	UGMCheatManager_SetNeckRight_Params params;
	params.RightAngle = RightAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetNeckMax
// (Final, Exec, Native, Public)
// Parameters:
// float                          MaxAngle                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetNeckMax(float MaxAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetNeckMax");

	UGMCheatManager_SetNeckMax_Params params;
	params.MaxAngle = MaxAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetNeckLeft
// (Final, Exec, Native, Public)
// Parameters:
// float                          LeftAngle                      (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetNeckLeft(float LeftAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetNeckLeft");

	UGMCheatManager_SetNeckLeft_Params params;
	params.LeftAngle = LeftAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetGVMemberID
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            memberID                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetGVMemberID(int memberID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetGVMemberID");

	UGMCheatManager_SetGVMemberID_Params params;
	params.memberID = memberID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetDeliver
// (Final, Exec, Native, Public)

void UGMCheatManager::SetDeliver()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetDeliver");

	UGMCheatManager_SetDeliver_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetCameraLagEnable
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetCameraLagEnable(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetCameraLagEnable");

	UGMCheatManager_SetCameraLagEnable_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetCacheInputNum
// (Final, Exec, Native, Public)
// Parameters:
// int                            CacheNum                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetCacheInputNum(int CacheNum)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetCacheInputNum");

	UGMCheatManager_SetCacheInputNum_Params params;
	params.CacheNum = CacheNum;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetBigYearBeastHP
// (Final, Exec, Native, Public)
// Parameters:
// int                            InHealth                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetBigYearBeastHP(int InHealth)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetBigYearBeastHP");

	UGMCheatManager_SetBigYearBeastHP_Params params;
	params.InHealth = InHealth;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetBigYearBeastDamageScale
// (Final, Exec, Native, Public)
// Parameters:
// float                          DamageScale                    (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetBigYearBeastDamageScale(float DamageScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetBigYearBeastDamageScale");

	UGMCheatManager_SetBigYearBeastDamageScale_Params params;
	params.DamageScale = DamageScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.SetAnimEnable
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::SetAnimEnable(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.SetAnimEnable");

	UGMCheatManager_SetAnimEnable_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.RefreshReconnectUI
// (Final, Exec, Native, Public)

void UGMCheatManager::RefreshReconnectUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.RefreshReconnectUI");

	UGMCheatManager_RefreshReconnectUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.PrintWeaponAllState
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::PrintWeaponAllState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.PrintWeaponAllState");

	UGMCheatManager_PrintWeaponAllState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.PrintMainCharAllAvatar
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::PrintMainCharAllAvatar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.PrintMainCharAllAvatar");

	UGMCheatManager_PrintMainCharAllAvatar_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.PrintAllAnim
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::PrintAllAnim()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.PrintAllAnim");

	UGMCheatManager_PrintAllAnim_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.PauseAnim
// (Final, Exec, Native, Public)
// Parameters:
// bool                           bPause                         (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::PauseAnim(bool bPause)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.PauseAnim");

	UGMCheatManager_PauseAnim_Params params;
	params.bPause = bPause;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.OpenHitTest
// (Final, Exec, Native, Public)

void UGMCheatManager::OpenHitTest()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.OpenHitTest");

	UGMCheatManager_OpenHitTest_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.OBKill
// (Final, Exec, Native, Public)

void UGMCheatManager::OBKill()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.OBKill");

	UGMCheatManager_OBKill_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.MoveToYearBeast
// (Final, Exec, Native, Public)

void UGMCheatManager::MoveToYearBeast()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.MoveToYearBeast");

	UGMCheatManager_MoveToYearBeast_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.KillBigYearBeast
// (Final, Exec, Native, Public)

void UGMCheatManager::KillBigYearBeast()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.KillBigYearBeast");

	UGMCheatManager_KillBigYearBeast_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GotoSpectating
// (Final, Exec, Native, Public)

void UGMCheatManager::GotoSpectating()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GotoSpectating");

	UGMCheatManager_GotoSpectating_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSuicide
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::GMSuicide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSuicide");

	UGMCheatManager_GMSuicide_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSpeedUp
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::GMSpeedUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSpeedUp");

	UGMCheatManager_GMSpeedUp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetSpeed
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// float                          WalkSpeed                      (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetSpeed(float WalkSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetSpeed");

	UGMCheatManager_GMSetSpeed_Params params;
	params.WalkSpeed = WalkSpeed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetServerLevelLoadingMode
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bNewLoadAll                    (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetServerLevelLoadingMode(bool bNewLoadAll)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetServerLevelLoadingMode");

	UGMCheatManager_GMSetServerLevelLoadingMode_Params params;
	params.bNewLoadAll = bNewLoadAll;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetJoystickEightDirection
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsNeedEightDirection           (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetJoystickEightDirection(bool IsNeedEightDirection)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetJoystickEightDirection");

	UGMCheatManager_GMSetJoystickEightDirection_Params params;
	params.IsNeedEightDirection = IsNeedEightDirection;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetJoystickActivatedRange
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsNeedActivatedRange           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ActivatedRange                 (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetJoystickActivatedRange(bool IsNeedActivatedRange, float ActivatedRange)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetJoystickActivatedRange");

	UGMCheatManager_GMSetJoystickActivatedRange_Params params;
	params.IsNeedActivatedRange = IsNeedActivatedRange;
	params.ActivatedRange = ActivatedRange;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetHealth
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetHealth(float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetHealth");

	UGMCheatManager_GMSetHealth_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMSetCircleTime
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// float                          CDTime                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          LastTime                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMSetCircleTime(float CDTime, float LastTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMSetCircleTime");

	UGMCheatManager_GMSetCircleTime_Params params;
	params.CDTime = CDTime;
	params.LastTime = LastTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMRainCount
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// float                          Count                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMRainCount(float Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMRainCount");

	UGMCheatManager_GMRainCount_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMIOSFrameRateLock
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            FrameRateLock                  (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMIOSFrameRateLock(int FrameRateLock)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMIOSFrameRateLock");

	UGMCheatManager_GMIOSFrameRateLock_Params params;
	params.FrameRateLock = FrameRateLock;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMInvincible
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsInvincible                   (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GMInvincible(bool IsInvincible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMInvincible");

	UGMCheatManager_GMInvincible_Params params;
	params.IsInvincible = IsInvincible;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMFollow
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 TargetName                     (Parm, ZeroConstructor)

void UGMCheatManager::GMFollow(const struct FString& TargetName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMFollow");

	UGMCheatManager_GMFollow_Params params;
	params.TargetName = TargetName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GMDecreaseHealth
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::GMDecreaseHealth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GMDecreaseHealth");

	UGMCheatManager_GMDecreaseHealth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.GetGVMemberID
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            memberID                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::GetGVMemberID(int memberID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.GetGVMemberID");

	UGMCheatManager_GetGVMemberID_Params params;
	params.memberID = memberID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ForceGC
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::ForceGC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ForceGC");

	UGMCheatManager_ForceGC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ForceEndInputForAppWillDeactivate
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::ForceEndInputForAppWillDeactivate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ForceEndInputForAppWillDeactivate");

	UGMCheatManager_ForceEndInputForAppWillDeactivate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.FallKill
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// int                            Type                           (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::FallKill(int Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.FallKill");

	UGMCheatManager_FallKill_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.EnterPawnState
// (Final, Exec, Native, Public)
// Parameters:
// EPawnState                     InState                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsEnter                        (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::EnterPawnState(EPawnState InState, bool IsEnter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.EnterPawnState");

	UGMCheatManager_EnterPawnState_Params params;
	params.InState = InState;
	params.IsEnter = IsEnter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.EnableFWAct
// (Final, Exec, Native, Public)
// Parameters:
// bool                           IsEnable                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::EnableFWAct(bool IsEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.EnableFWAct");

	UGMCheatManager_EnableFWAct_Params params;
	params.IsEnable = IsEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpVehicleAnimInstance
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpVehicleAnimInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpVehicleAnimInstance");

	UGMCheatManager_DumpVehicleAnimInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpVehicle
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpVehicle");

	UGMCheatManager_DumpVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpPlayerController
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpPlayerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpPlayerController");

	UGMCheatManager_DumpPlayerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpObservingCharacter
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpObservingCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpObservingCharacter");

	UGMCheatManager_DumpObservingCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpObjectProperties
// (Final, Exec, Native, Public, Const)
// Parameters:
// struct FString                 ObjectName                     (Parm, ZeroConstructor)

void UGMCheatManager::DumpObjectProperties(const struct FString& ObjectName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpObjectProperties");

	UGMCheatManager_DumpObjectProperties_Params params;
	params.ObjectName = ObjectName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpCharacterAnimInstance
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpCharacterAnimInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpCharacterAnimInstance");

	UGMCheatManager_DumpCharacterAnimInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DumpCharacter
// (Final, Exec, Native, Public, Const)

void UGMCheatManager::DumpCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DumpCharacter");

	UGMCheatManager_DumpCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugStopEMote
// (Final, Exec, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugStopEMote(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugStopEMote");

	UGMCheatManager_DebugStopEMote_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugStopCapture
// (Final, Exec, Native, Public, BlueprintCallable)

void UGMCheatManager::DebugStopCapture()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugStopCapture");

	UGMCheatManager_DebugStopCapture_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugStartEMote
// (Final, Exec, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugStartEMote(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugStartEMote");

	UGMCheatManager_DebugStartEMote_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugSpeed
// (Final, Exec, Native, Public)

void UGMCheatManager::DebugSpeed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugSpeed");

	UGMCheatManager_DebugSpeed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugOBNearPlayerList
// (Final, Exec, Native, Public)

void UGMCheatManager::DebugOBNearPlayerList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugOBNearPlayerList");

	UGMCheatManager_DebugOBNearPlayerList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugLocation
// (Final, Exec, Native, Public)

void UGMCheatManager::DebugLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugLocation");

	UGMCheatManager_DebugLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugFPPAnim
// (Final, Exec, Native, Public)

void UGMCheatManager::DebugFPPAnim()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugFPPAnim");

	UGMCheatManager_DebugFPPAnim_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugEnableSkeletalMeshAnimInitOptimization
// (Final, Exec, Native, Public)
// Parameters:
// int                            bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugEnableSkeletalMeshAnimInitOptimization(int bEnabled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugEnableSkeletalMeshAnimInitOptimization");

	UGMCheatManager_DebugEnableSkeletalMeshAnimInitOptimization_Params params;
	params.bEnabled = bEnabled;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugEnableFerrisWheelTick
// (Final, Exec, Native, Public)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugEnableFerrisWheelTick(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugEnableFerrisWheelTick");

	UGMCheatManager_DebugEnableFerrisWheelTick_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugEnableDrawSearchLine
// (Final, Exec, Native, Public)
// Parameters:
// int                            bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugEnableDrawSearchLine(int bEnabled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugEnableDrawSearchLine");

	UGMCheatManager_DebugEnableDrawSearchLine_Params params;
	params.bEnabled = bEnabled;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugEnableBulletImpact
// (Final, Exec, Native, Public)
// Parameters:
// int                            bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugEnableBulletImpact(int bEnabled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugEnableBulletImpact");

	UGMCheatManager_DebugEnableBulletImpact_Params params;
	params.bEnabled = bEnabled;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugCamera
// (Final, Exec, Native, Public)

void UGMCheatManager::DebugCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugCamera");

	UGMCheatManager_DebugCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.DebugAirDropPickInfo
// (Final, Exec, Native, Public)
// Parameters:
// float                          DrawTime                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          BoxDrawSize                    (Parm, ZeroConstructor, IsPlainOldData)
// float                          BoxDrawLineLength              (Parm, ZeroConstructor, IsPlainOldData)
// float                          ListWrapperDrawSize            (Parm, ZeroConstructor, IsPlainOldData)
// float                          ListWrapperDrawLineLength      (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::DebugAirDropPickInfo(float DrawTime, float BoxDrawSize, float BoxDrawLineLength, float ListWrapperDrawSize, float ListWrapperDrawLineLength)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.DebugAirDropPickInfo");

	UGMCheatManager_DebugAirDropPickInfo_Params params;
	params.DrawTime = DrawTime;
	params.BoxDrawSize = BoxDrawSize;
	params.BoxDrawLineLength = BoxDrawLineLength;
	params.ListWrapperDrawSize = ListWrapperDrawSize;
	params.ListWrapperDrawLineLength = ListWrapperDrawLineLength;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.CollectAllPlayerWeaponPosInfo
// (Final, Exec, Native, Public)

void UGMCheatManager::CollectAllPlayerWeaponPosInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.CollectAllPlayerWeaponPosInfo");

	UGMCheatManager_CollectAllPlayerWeaponPosInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.ChangeViewTarget
// (Final, Exec, Native, Public)

void UGMCheatManager::ChangeViewTarget()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.ChangeViewTarget");

	UGMCheatManager_ChangeViewTarget_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.CallOnReconnect
// (Final, Exec, Native, Public)

void UGMCheatManager::CallOnReconnect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.CallOnReconnect");

	UGMCheatManager_CallOnReconnect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.CallLuaTableFunction
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 TableName                      (Parm, ZeroConstructor)
// struct FString                 FunctionName                   (Parm, ZeroConstructor)

void UGMCheatManager::CallLuaTableFunction(const struct FString& TableName, const struct FString& FunctionName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.CallLuaTableFunction");

	UGMCheatManager_CallLuaTableFunction_Params params;
	params.TableName = TableName;
	params.FunctionName = FunctionName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.CallLuaGlobalFunction
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 FunctionName                   (Parm, ZeroConstructor)

void UGMCheatManager::CallLuaGlobalFunction(const struct FString& FunctionName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.CallLuaGlobalFunction");

	UGMCheatManager_CallLuaGlobalFunction_Params params;
	params.FunctionName = FunctionName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.BuildingCollide
// (Final, Exec, Native, Public)
// Parameters:
// bool                           InCollide                      (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::BuildingCollide(bool InCollide)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.BuildingCollide");

	UGMCheatManager_BuildingCollide_Params params;
	params.InCollide = InCollide;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.AutoSetPlayerLocation
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::AutoSetPlayerLocation(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.AutoSetPlayerLocation");

	UGMCheatManager_AutoSetPlayerLocation_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.AILog
// (Final, Exec, Native, Public)

void UGMCheatManager::AILog()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.AILog");

	UGMCheatManager_AILog_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.AddWeaponAvatar
// (Final, Exec, Native, Public)
// Parameters:
// int                            WeaponSkin                     (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::AddWeaponAvatar(int WeaponSkin)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.AddWeaponAvatar");

	UGMCheatManager_AddWeaponAvatar_Params params;
	params.WeaponSkin = WeaponSkin;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GMCheatManager.AddScore
// (Final, Exec, Native, Public)
// Parameters:
// int                            Score                          (Parm, ZeroConstructor, IsPlainOldData)

void UGMCheatManager::AddScore(int Score)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GMCheatManager.AddScore");

	UGMCheatManager_AddScore_Params params;
	params.Score = Score;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GrayPushCommand.InitConfigFile
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGrayPushCommand::InitConfigFile()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GrayPushCommand.InitConfigFile");

	UGrayPushCommand_InitConfigFile_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GrayPushCommand.GetPushCommands
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FString                 MapShortName                   (Parm, ZeroConstructor)
// struct FString                 GameModeName                   (Parm, ZeroConstructor)
// struct FString                 ProfileName                    (Parm, ZeroConstructor)
// struct FDeviceInfo             DeviceInfo                     (ConstParm, Parm, OutParm, ReferenceParm)
// TArray<struct FString>         PushComands                    (Parm, OutParm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UGrayPushCommand::GetPushCommands(const struct FString& MapShortName, const struct FString& GameModeName, const struct FString& ProfileName, const struct FDeviceInfo& DeviceInfo, TArray<struct FString>* PushComands)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GrayPushCommand.GetPushCommands");

	UGrayPushCommand_GetPushCommands_Params params;
	params.MapShortName = MapShortName;
	params.GameModeName = GameModeName;
	params.ProfileName = ProfileName;
	params.DeviceInfo = DeviceInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (PushComands != nullptr)
		*PushComands = params.PushComands;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GroundFlagWidget.SetWorldPos
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Loc                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UGroundFlagWidget::SetWorldPos(const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GroundFlagWidget.SetWorldPos");

	UGroundFlagWidget_SetWorldPos_Params params;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.ReconnectRecover
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideSuccessListenerBase::ReconnectRecover()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.ReconnectRecover");

	USTNewbieGuideSuccessListenerBase_ReconnectRecover_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.GuideFinishedByPlayer
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideSuccessListenerBase::GuideFinishedByPlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.GuideFinishedByPlayer");

	USTNewbieGuideSuccessListenerBase_GuideFinishedByPlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.EnableListener
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideSuccessListenerBase::EnableListener()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.EnableListener");

	USTNewbieGuideSuccessListenerBase_EnableListener_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.DisableListener
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideSuccessListenerBase::DisableListener()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideSuccessListenerBase.DisableListener");

	USTNewbieGuideSuccessListenerBase_DisableListener_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.GSListener_JoystickActive.ReceiveJoystickInput
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector2D               JSInput                        (Parm, IsPlainOldData)
// struct FVector2D               Size                           (Parm, IsPlainOldData)

void UGSListener_JoystickActive::ReceiveJoystickInput(const struct FVector2D& JSInput, const struct FVector2D& Size)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GSListener_JoystickActive.ReceiveJoystickInput");

	UGSListener_JoystickActive_ReceiveJoystickInput_Params params;
	params.JSInput = JSInput;
	params.Size = Size;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GSListener_PlayerUseRecoverItem.OnPlayerUseRecoverItem
// (Final, Native, Public)

void UGSListener_PlayerUseRecoverItem::OnPlayerUseRecoverItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GSListener_PlayerUseRecoverItem.OnPlayerUseRecoverItem");

	UGSListener_PlayerUseRecoverItem_OnPlayerUseRecoverItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GSListener_ShakeCamera.ReceiveCameraShake
// (Final, Native, Public)

void UGSListener_ShakeCamera::ReceiveCameraShake()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GSListener_ShakeCamera.ReceiveCameraShake");

	UGSListener_ShakeCamera_ReceiveCameraShake_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GSListener_SwitchToMainWeapon.OnCurUsingWeaponChange
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> targetSlot                     (Parm, ZeroConstructor, IsPlainOldData)

void UGSListener_SwitchToMainWeapon::OnCurUsingWeaponChange(TEnumAsByte<ESurviveWeaponPropSlot> targetSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GSListener_SwitchToMainWeapon.OnCurUsingWeaponChange");

	UGSListener_SwitchToMainWeapon_OnCurUsingWeaponChange_Params params;
	params.targetSlot = targetSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GuideComponent.SetMaskWidgetOnTop
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bTop                           (Parm, ZeroConstructor, IsPlainOldData)

void UGuideComponent::SetMaskWidgetOnTop(bool bTop)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GuideComponent.SetMaskWidgetOnTop");

	UGuideComponent_SetMaskWidgetOnTop_Params params;
	params.bTop = bTop;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.GuideComponent.CreateGuideUI
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UGuideComponent::CreateGuideUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.GuideComponent.CreateGuideUI");

	UGuideComponent_CreateGuideUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.IdeaFence.GetSplineComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USplineComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USplineComponent* AIdeaFence::GetSplineComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.IdeaFence.GetSplineComponent");

	AIdeaFence_GetSplineComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.InGameReconnectingInterface.RetriveDataAfterReconnecting
// (Native, Public)

void UInGameReconnectingInterface::RetriveDataAfterReconnecting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.InGameReconnectingInterface.RetriveDataAfterReconnecting");

	UInGameReconnectingInterface_RetriveDataAfterReconnecting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.InGameReconnectingInterface.RecoverStatusAfterReconnecting
// (Native, Public)

void UInGameReconnectingInterface::RecoverStatusAfterReconnecting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.InGameReconnectingInterface.RecoverStatusAfterReconnecting");

	UInGameReconnectingInterface_RecoverStatusAfterReconnecting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ItemGeneratorBase.ForceUpdate
// (Final, Native, Public, BlueprintCallable)

void AItemGeneratorBase::ForceUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ItemGeneratorBase.ForceUpdate");

	AItemGeneratorBase_ForceUpdate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetTreasureBoxGenerateDataList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 GroupName                      (Parm, ZeroConstructor)
// TArray<struct FAirDropBoxGenerateWrapperItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FAirDropBoxGenerateWrapperItemData> UItemsBoxConfigDataAsset::GetTreasureBoxGenerateDataList(const struct FString& GroupName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetTreasureBoxGenerateDataList");

	UItemsBoxConfigDataAsset_GetTreasureBoxGenerateDataList_Params params;
	params.GroupName = GroupName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetTargetItemsDataFromTableByCategoryFilter
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// struct FString                 CategoryFilter                 (Parm, ZeroConstructor)
// TArray<struct FAirDropBoxGenerateWrapperItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FAirDropBoxGenerateWrapperItemData> UItemsBoxConfigDataAsset::GetTargetItemsDataFromTableByCategoryFilter(const struct FString& CategoryFilter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetTargetItemsDataFromTableByCategoryFilter");

	UItemsBoxConfigDataAsset_GetTargetItemsDataFromTableByCategoryFilter_Params params;
	params.CategoryFilter = CategoryFilter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetSuperAirDropBoxGenerateDataList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            GroupIdx                       (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FAirDropBoxGenerateWrapperItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FAirDropBoxGenerateWrapperItemData> UItemsBoxConfigDataAsset::GetSuperAirDropBoxGenerateDataList(int GroupIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetSuperAirDropBoxGenerateDataList");

	UItemsBoxConfigDataAsset_GetSuperAirDropBoxGenerateDataList_Params params;
	params.GroupIdx = GroupIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetAirDropBoxGenerateDataList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FAirDropBoxGenerateWrapperItemData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FAirDropBoxGenerateWrapperItemData> UItemsBoxConfigDataAsset::GetAirDropBoxGenerateDataList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ItemsBoxConfigDataAsset.GetAirDropBoxGenerateDataList");

	UItemsBoxConfigDataAsset_GetAirDropBoxGenerateDataList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.LagCompensationComponent.SimulatedCharacterServerTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ULagCompensationComponent::SimulatedCharacterServerTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LagCompensationComponent.SimulatedCharacterServerTime");

	ULagCompensationComponent_SimulatedCharacterServerTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.LagCompensationComponent.RPC_DrawHeadBox
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// struct FCharacterHistoryData   DataToDraw                     (Parm)

void ULagCompensationComponent::RPC_DrawHeadBox(const struct FCharacterHistoryData& DataToDraw)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LagCompensationComponent.RPC_DrawHeadBox");

	ULagCompensationComponent_RPC_DrawHeadBox_Params params;
	params.DataToDraw = DataToDraw;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LandScapeLODByHeight.Stop
// (Final, Native, Public, BlueprintCallable)

void ULandScapeLODByHeight::Stop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LandScapeLODByHeight.Stop");

	ULandScapeLODByHeight_Stop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LandScapeLODByHeight.Start
// (Final, Native, Public, BlueprintCallable)

void ULandScapeLODByHeight::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LandScapeLODByHeight.Start");

	ULandScapeLODByHeight_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LandScapeLODByHeight.MappingLODByHeight
// (Final, Native, Private)

void ULandScapeLODByHeight::MappingLODByHeight()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LandScapeLODByHeight.MappingLODByHeight");

	ULandScapeLODByHeight_MappingLODByHeight_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LobbyMatChgActor.ChangeMaterialToIdx
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Idx                            (Parm, ZeroConstructor, IsPlainOldData)

void ALobbyMatChgActor::ChangeMaterialToIdx(int Idx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LobbyMatChgActor.ChangeMaterialToIdx");

	ALobbyMatChgActor_ChangeMaterialToIdx_Params params;
	params.Idx = Idx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LobbyNianMonster.GetMonsterStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ALobbyNianMonster::GetMonsterStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LobbyNianMonster.GetMonsterStatus");

	ALobbyNianMonster_GetMonsterStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.LobbyNianMonster.ChangeNianStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Status                         (Parm, ZeroConstructor, IsPlainOldData)

void ALobbyNianMonster::ChangeNianStatus(int Status)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LobbyNianMonster.ChangeNianStatus");

	ALobbyNianMonster_ChangeNianStatus_Params params;
	params.Status = Status;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.SetTeammateForbitPick
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// bool                           bForbit                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            LogType                        (Parm, ZeroConstructor, IsPlainOldData)

void ULockAndObsOptComponent::SetTeammateForbitPick(bool bForbit, int LogType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.SetTeammateForbitPick");

	ULockAndObsOptComponent_SetTeammateForbitPick_Params params;
	params.bForbit = bForbit;
	params.LogType = LogType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_ForbitPickEffect
// (Final, Native, Public)

void ULockAndObsOptComponent::OnRep_ForbitPickEffect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_ForbitPickEffect");

	ULockAndObsOptComponent_OnRep_ForbitPickEffect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_ForbitPick
// (Final, Native, Public)

void ULockAndObsOptComponent::OnRep_ForbitPick()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_ForbitPick");

	ULockAndObsOptComponent_OnRep_ForbitPick_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_CanImprisonmentTeammate
// (Final, Native, Public)

void ULockAndObsOptComponent::OnRep_CanImprisonmentTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.OnRep_CanImprisonmentTeammate");

	ULockAndObsOptComponent_OnRep_CanImprisonmentTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.IsForbitPickMakeEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ULockAndObsOptComponent::IsForbitPickMakeEffect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.IsForbitPickMakeEffect");

	ULockAndObsOptComponent_IsForbitPickMakeEffect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.IsForbitPick
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FName                   tombName                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ULockAndObsOptComponent::IsForbitPick(const struct FName& tombName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.IsForbitPick");

	ULockAndObsOptComponent_IsForbitPick_Params params;
	params.tombName = tombName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.LockAndObsOptComponent.IsCanImprisonmentTeammate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ULockAndObsOptComponent::IsCanImprisonmentTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.LockAndObsOptComponent.IsCanImprisonmentTeammate");

	ULockAndObsOptComponent_IsCanImprisonmentTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MathUtils.AngleDis
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                          angleA                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          angleB                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UMathUtils::AngleDis(float angleA, float angleB)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MathUtils.AngleDis");

	UMathUtils_AngleDis_Params params;
	params.angleA = angleA;
	params.angleB = angleB;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MeleeWeaponToSkillInterface.GetSkillEntryForMeleeWeapon
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                           IsPressed                      (Parm, ZeroConstructor, IsPlainOldData)
// EUTSkillEntry                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EUTSkillEntry UMeleeWeaponToSkillInterface::GetSkillEntryForMeleeWeapon(bool IsPressed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MeleeWeaponToSkillInterface.GetSkillEntryForMeleeWeapon");

	UMeleeWeaponToSkillInterface_GetSkillEntryForMeleeWeapon_Params params;
	params.IsPressed = IsPressed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MinimapWidget.UpdatePlayersLocAndRotC
// (Final, Native, Private)

void UMinimapWidget::UpdatePlayersLocAndRotC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.UpdatePlayersLocAndRotC");

	UMinimapWidget_UpdatePlayersLocAndRotC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.UpdateLeftRouteLengthC
// (Final, Native, Private)

void UMinimapWidget::UpdateLeftRouteLengthC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.UpdateLeftRouteLengthC");

	UMinimapWidget_UpdateLeftRouteLengthC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.UpdateLastDriveVehicleC
// (Final, Native, Private)

void UMinimapWidget::UpdateLastDriveVehicleC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.UpdateLastDriveVehicleC");

	UMinimapWidget_UpdateLastDriveVehicleC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.UpdateAirIconC
// (Final, Native, Private)

void UMinimapWidget::UpdateAirIconC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.UpdateAirIconC");

	UMinimapWidget_UpdateAirIconC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.TickDynamicScaleC
// (Final, Native, Private)
// Parameters:
// float                          DeltaSec                       (Parm, ZeroConstructor, IsPlainOldData)

void UMinimapWidget::TickDynamicScaleC(float DeltaSec)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.TickDynamicScaleC");

	UMinimapWidget_TickDynamicScaleC_Params params;
	params.DeltaSec = DeltaSec;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.TickCircleC
// (Final, Native, Private)

void UMinimapWidget::TickCircleC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.TickCircleC");

	UMinimapWidget_TickCircleC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.RepositionItemOnMapC
// (Event, Protected, BlueprintEvent)

void UMinimapWidget::RepositionItemOnMapC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.RepositionItemOnMapC");

	UMinimapWidget_RepositionItemOnMapC_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.ReCalMapInfoC
// (Final, Native, Protected, BlueprintCallable)

void UMinimapWidget::ReCalMapInfoC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.ReCalMapInfoC");

	UMinimapWidget_ReCalMapInfoC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.MapResizeC
// (Event, Protected, BlueprintEvent)

void UMinimapWidget::MapResizeC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.MapResizeC");

	UMinimapWidget_MapResizeC_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.LerpDynamicScaleC
// (Final, Native, Private)
// Parameters:
// float                          DeltaSec                       (Parm, ZeroConstructor, IsPlainOldData)

void UMinimapWidget::LerpDynamicScaleC(float DeltaSec)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.LerpDynamicScaleC");

	UMinimapWidget_LerpDynamicScaleC_Params params;
	params.DeltaSec = DeltaSec;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.HandleTeammateOutOfRangeC
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UWidget*                 Widget                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           bIsInRange                     (Parm, ZeroConstructor, IsPlainOldData)

void UMinimapWidget::HandleTeammateOutOfRangeC(class UWidget* Widget, bool bIsInRange)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.HandleTeammateOutOfRangeC");

	UMinimapWidget_HandleTeammateOutOfRangeC_Params params;
	params.Widget = Widget;
	params.bIsInRange = bIsInRange;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.FindScaleFactorByVelocityC
// (Final, Native, Private)
// Parameters:
// float                          Velocity                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UMinimapWidget::FindScaleFactorByVelocityC(float Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.FindScaleFactorByVelocityC");

	UMinimapWidget_FindScaleFactorByVelocityC_Params params;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MinimapWidget.ChangeDynamicScaleC
// (Final, Native, Private)
// Parameters:
// float                          NewScale                       (Parm, ZeroConstructor, IsPlainOldData)

void UMinimapWidget::ChangeDynamicScaleC(float NewScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.ChangeDynamicScaleC");

	UMinimapWidget_ChangeDynamicScaleC_Params params;
	params.NewScale = NewScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MinimapWidget.AdjustMapPositionC
// (Final, Native, Private)

void UMinimapWidget::AdjustMapPositionC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MinimapWidget.AdjustMapPositionC");

	UMinimapWidget_AdjustMapPositionC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterGeneratorComponent.StartGeneratorMonster
// (Final, Native, Public, BlueprintCallable)

void UMonsterGeneratorComponent::StartGeneratorMonster()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterGeneratorComponent.StartGeneratorMonster");

	UMonsterGeneratorComponent_StartGeneratorMonster_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterGeneratorComponent.RegisterSpotComponent
// (Final, Native, Public)
// Parameters:
// class UMonsterSpotComponent*   MonsterSpotComponent           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UMonsterGeneratorComponent::RegisterSpotComponent(class UMonsterSpotComponent* MonsterSpotComponent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterGeneratorComponent.RegisterSpotComponent");

	UMonsterGeneratorComponent_RegisterSpotComponent_Params params;
	params.MonsterSpotComponent = MonsterSpotComponent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterGeneratorComponent.GeneratorMonser
// (Final, Native, Public)

void UMonsterGeneratorComponent::GeneratorMonser()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterGeneratorComponent.GeneratorMonser");

	UMonsterGeneratorComponent_GeneratorMonser_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.UpdateDamageRanking
// (Final, Native, Public)
// Parameters:
// class ABRPlayerState_YearBeast* YearBeastPlayerState           (Parm, ZeroConstructor, IsPlainOldData)
// float                          FinalDamage                    (Parm, ZeroConstructor, IsPlainOldData)

void AMonsterPlayerState::UpdateDamageRanking(class ABRPlayerState_YearBeast* YearBeastPlayerState, float FinalDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.UpdateDamageRanking");

	AMonsterPlayerState_UpdateDamageRanking_Params params;
	params.YearBeastPlayerState = YearBeastPlayerState;
	params.FinalDamage = FinalDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.OutputDebugInfo
// (Final, Native, Public)

void AMonsterPlayerState::OutputDebugInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.OutputDebugInfo");

	AMonsterPlayerState_OutputDebugInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.OnTakeDamage
// (Final, Native, Public)
// Parameters:
// float                          FinalDamage                    (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerState*     EventInstigator                (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 HurtTime                       (Parm, ZeroConstructor)

void AMonsterPlayerState::OnTakeDamage(float FinalDamage, class ASTExtraPlayerState* EventInstigator, const struct FString& HurtTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.OnTakeDamage");

	AMonsterPlayerState_OnTakeDamage_Params params;
	params.FinalDamage = FinalDamage;
	params.EventInstigator = EventInstigator;
	params.HurtTime = HurtTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.OnRep_InstigatorList
// (Final, Native, Public)

void AMonsterPlayerState::OnRep_InstigatorList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.OnRep_InstigatorList");

	AMonsterPlayerState_OnRep_InstigatorList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.OnRep_DamageFlows
// (Final, Native, Public)

void AMonsterPlayerState::OnRep_DamageFlows()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.OnRep_DamageFlows");

	AMonsterPlayerState_OnRep_DamageFlows_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterPlayerState.InitDamageRanking
// (Final, Native, Public)
// Parameters:
// TArray<class ABRPlayerState_YearBeast*> PlayerStateList                (Parm, ZeroConstructor)

void AMonsterPlayerState::InitDamageRanking(TArray<class ABRPlayerState_YearBeast*> PlayerStateList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterPlayerState.InitDamageRanking");

	AMonsterPlayerState_InitDamageRanking_Params params;
	params.PlayerStateList = PlayerStateList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterProbeComponent.InitialItemTable
// (Native, Event, Public, BlueprintEvent)

void UMonsterProbeComponent::InitialItemTable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterProbeComponent.InitialItemTable");

	UMonsterProbeComponent_InitialItemTable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterSpotComponent.LineTraceSingle
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Start                          (ConstParm, Parm, IsPlainOldData)
// struct FVector                 End                            (ConstParm, Parm, IsPlainOldData)
// bool                           bTraceComplex                  (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          ActorsToIgnore                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FHitResult              OutHit                         (Parm, OutParm, IsPlainOldData)
// bool                           bIgnoreSelf                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UMonsterSpotComponent::LineTraceSingle(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, bool bIgnoreSelf, struct FHitResult* OutHit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterSpotComponent.LineTraceSingle");

	UMonsterSpotComponent_LineTraceSingle_Params params;
	params.WorldContextObject = WorldContextObject;
	params.Start = Start;
	params.End = End;
	params.bTraceComplex = bTraceComplex;
	params.ActorsToIgnore = ActorsToIgnore;
	params.bIgnoreSelf = bIgnoreSelf;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutHit != nullptr)
		*OutHit = params.OutHit;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MonsterSpotComponent.GeneratorMonster
// (Native, Public)

void UMonsterSpotComponent::GeneratorMonster()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterSpotComponent.GeneratorMonster");

	UMonsterSpotComponent_GeneratorMonster_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MonsterSpotComponent.GenerateActor
// (Native, Public, HasDefaults)
// Parameters:
// class UClass*                  ActorClass                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ActorLocation                  (Parm, IsPlainOldData)
// struct FRotator                ActorRotator                   (Parm, IsPlainOldData)
// ESpawnActorCollisionHandlingMethod SpawnActorCollisionHandlingMethod (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* UMonsterSpotComponent::GenerateActor(class UClass* ActorClass, const struct FVector& ActorLocation, const struct FRotator& ActorRotator, ESpawnActorCollisionHandlingMethod SpawnActorCollisionHandlingMethod)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterSpotComponent.GenerateActor");

	UMonsterSpotComponent_GenerateActor_Params params;
	params.ActorClass = ActorClass;
	params.ActorLocation = ActorLocation;
	params.ActorRotator = ActorRotator;
	params.SpawnActorCollisionHandlingMethod = SpawnActorCollisionHandlingMethod;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.MonsterSpotComponent.CleanUpMonsters
// (Final, Native, Protected)

void UMonsterSpotComponent::CleanUpMonsters()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MonsterSpotComponent.CleanUpMonsters");

	UMonsterSpotComponent_CleanUpMonsters_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MoveAntiCheatComponent.Ping2Server
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// float                          ServerTime                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          ClientTime                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLoc                      (ConstParm, Parm, ReferenceParm)
// float                          MaxSpeed                       (Parm, ZeroConstructor, IsPlainOldData)

void UMoveAntiCheatComponent::Ping2Server(float ServerTime, float ClientTime, const struct FVector_NetQuantize100& ClientLoc, float MaxSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MoveAntiCheatComponent.Ping2Server");

	UMoveAntiCheatComponent_Ping2Server_Params params;
	params.ServerTime = ServerTime;
	params.ClientTime = ClientTime;
	params.ClientLoc = ClientLoc;
	params.MaxSpeed = MaxSpeed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MoveAntiCheatComponent.Ping2Client
// (Net, Native, Event, Public, NetClient)
// Parameters:
// float                          ServerTime                     (Parm, ZeroConstructor, IsPlainOldData)

void UMoveAntiCheatComponent::Ping2Client(float ServerTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MoveAntiCheatComponent.Ping2Client");

	UMoveAntiCheatComponent_Ping2Client_Params params;
	params.ServerTime = ServerTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MoveAntiCheatComponent.OnPreReconnectOnServer
// (Final, Native, Public)

void UMoveAntiCheatComponent::OnPreReconnectOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MoveAntiCheatComponent.OnPreReconnectOnServer");

	UMoveAntiCheatComponent_OnPreReconnectOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MoveAntiCheatComponent.DebugDrawLine
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 Start                          (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 End                            (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void UMoveAntiCheatComponent::DebugDrawLine(const struct FVector& Start, const struct FVector& End)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MoveAntiCheatComponent.DebugDrawLine");

	UMoveAntiCheatComponent_DebugDrawLine_Params params;
	params.Start = Start;
	params.End = End;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MyLandscape.GameEventFlying
// (Final, Native, Private)

void AMyLandscape::GameEventFlying()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MyLandscape.GameEventFlying");

	AMyLandscape_GameEventFlying_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MyLandscape.GameEventFighting
// (Final, Native, Private)

void AMyLandscape::GameEventFighting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MyLandscape.GameEventFighting");

	AMyLandscape_GameEventFighting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.MyLandscape.AboutToSwitchViewTargetPlayer
// (Final, Native, Private)

void AMyLandscape::AboutToSwitchViewTargetPlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.MyLandscape.AboutToSwitchViewTargetPlayer");

	AMyLandscape_AboutToSwitchViewTargetPlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateSafeZoneGuideVisibilityAndPosition
// (Final, Native, Protected)

void UNavigatorPannelUAEUserWidget::UpdateSafeZoneGuideVisibilityAndPosition()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateSafeZoneGuideVisibilityAndPosition");

	UNavigatorPannelUAEUserWidget_UpdateSafeZoneGuideVisibilityAndPosition_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateMapMarkVisibility
// (Final, Native, Protected)

void UNavigatorPannelUAEUserWidget::UpdateMapMarkVisibility()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateMapMarkVisibility");

	UNavigatorPannelUAEUserWidget_UpdateMapMarkVisibility_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateMapMarkPosition
// (Final, Native, Protected)

void UNavigatorPannelUAEUserWidget::UpdateMapMarkPosition()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.UpdateMapMarkPosition");

	UNavigatorPannelUAEUserWidget_UpdateMapMarkPosition_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.SetCompassMat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UMaterialInstanceDynamic* InCompassMat                   (Parm, ZeroConstructor, IsPlainOldData)

void UNavigatorPannelUAEUserWidget::SetCompassMat(class UMaterialInstanceDynamic* InCompassMat)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.SetCompassMat");

	UNavigatorPannelUAEUserWidget_SetCompassMat_Params params;
	params.InCompassMat = InCompassMat;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.OnMapMarkChange_NoParam
// (Final, Native, Protected, BlueprintCallable)

void UNavigatorPannelUAEUserWidget::OnMapMarkChange_NoParam()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.OnMapMarkChange_NoParam");

	UNavigatorPannelUAEUserWidget_OnMapMarkChange_NoParam_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.OnMapMarkChange
// (Final, Native, Protected)
// Parameters:
// int                            MarkIndex                      (Parm, ZeroConstructor, IsPlainOldData)

void UNavigatorPannelUAEUserWidget::OnMapMarkChange(int MarkIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.OnMapMarkChange");

	UNavigatorPannelUAEUserWidget_OnMapMarkChange_Params params;
	params.MarkIndex = MarkIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.GetPlayerLookRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator UNavigatorPannelUAEUserWidget::GetPlayerLookRotation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.GetPlayerLookRotation");

	UNavigatorPannelUAEUserWidget_GetPlayerLookRotation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.BindMapMarkChangeDelegate
// (Final, Native, Protected, BlueprintCallable)

void UNavigatorPannelUAEUserWidget::BindMapMarkChangeDelegate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NavigatorPannelUAEUserWidget.BindMapMarkChangeDelegate");

	UNavigatorPannelUAEUserWidget_BindMapMarkChangeDelegate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.SwitchPoseStateServer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     PoseState                      (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::SwitchPoseStateServer(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEPoseState> PoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.SwitchPoseStateServer");

	ANetworkOnlineDriver_SwitchPoseStateServer_Params params;
	params.TargetCharacter = TargetCharacter;
	params.PoseState = PoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.SwitchPoseStateClient
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     PoseState                      (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::SwitchPoseStateClient(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEPoseState> PoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.SwitchPoseStateClient");

	ANetworkOnlineDriver_SwitchPoseStateClient_Params params;
	params.TargetCharacter = TargetCharacter;
	params.PoseState = PoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStopFire
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurrentBullet                  (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::ServerStopFire(class ASTExtraBaseCharacter* TargetCharacter, int CurrentBullet)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStopFire");

	ANetworkOnlineDriver_ServerStopFire_Params params;
	params.TargetCharacter = TargetCharacter;
	params.CurrentBullet = CurrentBullet;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStartFire
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// int                            BurstShootBulletsLimit         (Parm, ZeroConstructor, IsPlainOldData)
// float                          BurstShootTimeLimit            (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EShootWeaponShootMode> ShootMode                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 SimpleShootTarget              (Parm, IsPlainOldData)
// struct FVector2D               ClientScreenSize               (Parm, IsPlainOldData)

void ANetworkOnlineDriver::ServerStartFire(class ASTExtraBaseCharacter* TargetCharacter, int BurstShootBulletsLimit, float BurstShootTimeLimit, TEnumAsByte<EShootWeaponShootMode> ShootMode, const struct FVector& SimpleShootTarget, const struct FVector2D& ClientScreenSize)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStartFire");

	ANetworkOnlineDriver_ServerStartFire_Params params;
	params.TargetCharacter = TargetCharacter;
	params.BurstShootBulletsLimit = BurstShootBulletsLimit;
	params.BurstShootTimeLimit = BurstShootTimeLimit;
	params.ShootMode = ShootMode;
	params.SimpleShootTarget = SimpleShootTarget;
	params.ClientScreenSize = ClientScreenSize;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStartBarrel
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::ServerStartBarrel(class ASTExtraBaseCharacter* TargetCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerStartBarrel");

	ANetworkOnlineDriver_ServerStartBarrel_Params params;
	params.TargetCharacter = TargetCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerSetShootType
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEWeaponShootType> shootType                      (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::ServerSetShootType(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<ESTEWeaponShootType> shootType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerSetShootType");

	ANetworkOnlineDriver_ServerSetShootType_Params params;
	params.TargetCharacter = TargetCharacter;
	params.shootType = shootType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerSetReloadMethod
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   TargetCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EWeaponReloadMethod> reloadMethod                   (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::ServerSetReloadMethod(class ASTExtraBaseCharacter* TargetCharacter, TEnumAsByte<EWeaponReloadMethod> reloadMethod)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerSetReloadMethod");

	ANetworkOnlineDriver_ServerSetReloadMethod_Params params;
	params.TargetCharacter = TargetCharacter;
	params.reloadMethod = reloadMethod;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.ServerReplicateExplosionEffect
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// class UClass*                  Template                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FTransform              Trans                          (Parm, IsPlainOldData)
// class AActor*                  ActorOwner                     (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   InstigatorPawn                 (Parm, ZeroConstructor, IsPlainOldData)
// ESpawnActorCollisionHandlingMethod method                         (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::ServerReplicateExplosionEffect(class UClass* Template, const struct FTransform& Trans, class AActor* ActorOwner, class APawn* InstigatorPawn, ESpawnActorCollisionHandlingMethod method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.ServerReplicateExplosionEffect");

	ANetworkOnlineDriver_ServerReplicateExplosionEffect_Params params;
	params.Template = Template;
	params.Trans = Trans;
	params.ActorOwner = ActorOwner;
	params.InstigatorPawn = InstigatorPawn;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NetworkOnlineDriver.BroadcastClientsSpawnExplosionEffect
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, NetValidate)
// Parameters:
// class UClass*                  Template                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FTransform              Trans                          (Parm, IsPlainOldData)
// class AActor*                  ActorOwner                     (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   InstigatorPawn                 (Parm, ZeroConstructor, IsPlainOldData)
// ESpawnActorCollisionHandlingMethod method                         (Parm, ZeroConstructor, IsPlainOldData)

void ANetworkOnlineDriver::BroadcastClientsSpawnExplosionEffect(class UClass* Template, const struct FTransform& Trans, class AActor* ActorOwner, class APawn* InstigatorPawn, ESpawnActorCollisionHandlingMethod method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NetworkOnlineDriver.BroadcastClientsSpawnExplosionEffect");

	ANetworkOnlineDriver_BroadcastClientsSpawnExplosionEffect_Params params;
	params.Template = Template;
	params.Trans = Trans;
	params.ActorOwner = ActorOwner;
	params.InstigatorPawn = InstigatorPawn;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STNewbieGuideConditionBase.ReconnectRecover
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideConditionBase::ReconnectRecover()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideConditionBase.ReconnectRecover");

	USTNewbieGuideConditionBase_ReconnectRecover_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STNewbieGuideConditionBase.IsOK
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTNewbieGuideConditionBase::IsOK()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STNewbieGuideConditionBase.IsOK");

	USTNewbieGuideConditionBase_IsOK_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.NewbieGuideComponent.SendNewbieMsg
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            tipsID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isStart                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            tipsIndex                      (Parm, ZeroConstructor, IsPlainOldData)

void UNewbieGuideComponent::SendNewbieMsg(int tipsID, bool isStart, int tipsIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NewbieGuideComponent.SendNewbieMsg");

	UNewbieGuideComponent_SendNewbieMsg_Params params;
	params.tipsID = tipsID;
	params.isStart = isStart;
	params.tipsIndex = tipsIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NewbieGuideComponent.InitComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* _OwnerController               (Parm, ZeroConstructor, IsPlainOldData)
// TArray<int>                    _FinishedTips                  (Parm, ZeroConstructor)
// TArray<int>                    _FinishedCounts                (Parm, ZeroConstructor)
// TEnumAsByte<ENewbieGuidePlayerCategory> curPlayerCategory              (Parm, ZeroConstructor, IsPlainOldData)

void UNewbieGuideComponent::InitComponent(class ASTExtraPlayerController* _OwnerController, TArray<int> _FinishedTips, TArray<int> _FinishedCounts, TEnumAsByte<ENewbieGuidePlayerCategory> curPlayerCategory)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NewbieGuideComponent.InitComponent");

	UNewbieGuideComponent_InitComponent_Params params;
	params._OwnerController = _OwnerController;
	params._FinishedTips = _FinishedTips;
	params._FinishedCounts = _FinishedCounts;
	params.curPlayerCategory = curPlayerCategory;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.NightVisionComponent.SetActivate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           _IsActivate                    (Parm, ZeroConstructor, IsPlainOldData)

void UNightVisionComponent::SetActivate(bool _IsActivate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.NightVisionComponent.SetActivate");

	UNightVisionComponent_SetActivate_Params params;
	params._IsActivate = _IsActivate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OBModeAirDropWidget.SetAirDrop
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AAirDropBoxActor*        DropBox                        (Parm, ZeroConstructor, IsPlainOldData)

void UOBModeAirDropWidget::SetAirDrop(class AAirDropBoxActor* DropBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OBModeAirDropWidget.SetAirDrop");

	UOBModeAirDropWidget_SetAirDrop_Params params;
	params.DropBox = DropBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OBModeAirDropWidget.OnItemClicked
// (Final, Native, Public, BlueprintCallable)

void UOBModeAirDropWidget::OnItemClicked()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OBModeAirDropWidget.OnItemClicked");

	UOBModeAirDropWidget_OnItemClicked_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OBModePositionWidget.SetPlayerCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            Idx                            (Parm, ZeroConstructor, IsPlainOldData)

void UOBModePositionWidget::SetPlayerCharacter(class ASTExtraPlayerController* Controller, int Idx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OBModePositionWidget.SetPlayerCharacter");

	UOBModePositionWidget_SetPlayerCharacter_Params params;
	params.Controller = Controller;
	params.Idx = Idx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OBModePositionWidget.RefreshPlayerHealth
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          hpRatio                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          breathRatio                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsNearDeath                    (Parm, ZeroConstructor, IsPlainOldData)

void UOBModePositionWidget::RefreshPlayerHealth(float hpRatio, float breathRatio, bool IsNearDeath)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OBModePositionWidget.RefreshPlayerHealth");

	UOBModePositionWidget_RefreshPlayerHealth_Params params;
	params.hpRatio = hpRatio;
	params.breathRatio = breathRatio;
	params.IsNearDeath = IsNearDeath;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OBModePositionWidget.OnItemClicked
// (Final, Native, Public, BlueprintCallable)

void UOBModePositionWidget::OnItemClicked()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OBModePositionWidget.OnItemClicked");

	UOBModePositionWidget_OnItemClicked_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ObserverCameraComponent.GetCameraView
// (Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FMinimalViewInfo        DesiredView                    (Parm, OutParm)

void UObserverCameraComponent::GetCameraView(float DeltaTime, struct FMinimalViewInfo* DesiredView)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ObserverCameraComponent.GetCameraView");

	UObserverCameraComponent_GetCameraView_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DesiredView != nullptr)
		*DesiredView = params.DesiredView;
}


// Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.SpawnLevelDirector
// (Native, Public)
// Parameters:
// class UClass*                  LevelDirectorClass             (Parm, ZeroConstructor, IsPlainOldData)

void UOnTimeSpawnChallengeLevelRules::SpawnLevelDirector(class UClass* LevelDirectorClass)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.SpawnLevelDirector");

	UOnTimeSpawnChallengeLevelRules_SpawnLevelDirector_Params params;
	params.LevelDirectorClass = LevelDirectorClass;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.OnReceiveTriggerMsg
// (Native, Public)
// Parameters:
// class UTriggerAction*          TriggerAction                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 Msg                            (Parm, ZeroConstructor)

void UOnTimeSpawnChallengeLevelRules::OnReceiveTriggerMsg(class UTriggerAction* TriggerAction, const struct FString& Msg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.OnReceiveTriggerMsg");

	UOnTimeSpawnChallengeLevelRules_OnReceiveTriggerMsg_Params params;
	params.TriggerAction = TriggerAction;
	params.Msg = Msg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.InitLevel
// (Native, Public)

void UOnTimeSpawnChallengeLevelRules::InitLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.OnTimeSpawnChallengeLevelRules.InitLevel");

	UOnTimeSpawnChallengeLevelRules_InitLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PhaseActorInterface.SetSkillOwnerActor
// (Native, Public)
// Parameters:
// class AActor*                  soa                            (Parm, ZeroConstructor, IsPlainOldData)

void UPhaseActorInterface::SetSkillOwnerActor(class AActor* soa)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PhaseActorInterface.SetSkillOwnerActor");

	UPhaseActorInterface_SetSkillOwnerActor_Params params;
	params.soa = soa;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PhaseActorInterface.SendPhaseEvent
// (Native, Public)
// Parameters:
// TEnumAsByte<EUTSkillEventType> _type                          (Parm, ZeroConstructor, IsPlainOldData)

void UPhaseActorInterface::SendPhaseEvent(TEnumAsByte<EUTSkillEventType> _type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PhaseActorInterface.SendPhaseEvent");

	UPhaseActorInterface_SendPhaseEvent_Params params;
	params._type = _type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PhaseActorInterface.GetSkillOwnerActor
// (Native, Public)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* UPhaseActorInterface::GetSkillOwnerActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PhaseActorInterface.GetSkillOwnerActor");

	UPhaseActorInterface_GetSkillOwnerActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ServerPutDownTargetWithLocation
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void UPickupManagerComponent::ServerPutDownTargetWithLocation(class AActor* Target, const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ServerPutDownTargetWithLocation");

	UPickupManagerComponent_ServerPutDownTargetWithLocation_Params params;
	params.Target = Target;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ServerPutDownTarget
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::ServerPutDownTarget(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ServerPutDownTarget");

	UPickupManagerComponent_ServerPutDownTarget_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ServerPickUpTarget
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::ServerPickUpTarget(class AActor* Target, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ServerPickUpTarget");

	UPickupManagerComponent_ServerPickUpTarget_Params params;
	params.Target = Target;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.PutDownTargetWithLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void UPickupManagerComponent::PutDownTargetWithLocation(class AActor* Target, const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.PutDownTargetWithLocation");

	UPickupManagerComponent_PutDownTargetWithLocation_Params params;
	params.Target = Target;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.PutDownTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::PutDownTarget(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.PutDownTarget");

	UPickupManagerComponent_PutDownTarget_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.PickUpTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::PickUpTarget(class AActor* Target, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.PickUpTarget");

	UPickupManagerComponent_PickUpTarget_Params params;
	params.Target = Target;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.NotifyMissPickupAvailableActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::NotifyMissPickupAvailableActor(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.NotifyMissPickupAvailableActor");

	UPickupManagerComponent_NotifyMissPickupAvailableActor_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.NotifyMeetPickupAvailableActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::NotifyMeetPickupAvailableActor(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.NotifyMeetPickupAvailableActor");

	UPickupManagerComponent_NotifyMeetPickupAvailableActor_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.GetRandomPutDownLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                          OverrideFindPutDownPointZThreshold (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector UPickupManagerComponent::GetRandomPutDownLocation(float OverrideFindPutDownPointZThreshold)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.GetRandomPutDownLocation");

	UPickupManagerComponent_GetRandomPutDownLocation_Params params;
	params.OverrideFindPutDownPointZThreshold = OverrideFindPutDownPointZThreshold;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PickupManagerComponent.GetConfirmedPickupAvailableActors
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)

void UPickupManagerComponent::GetConfirmedPickupAvailableActors()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.GetConfirmedPickupAvailableActors");

	UPickupManagerComponent_GetConfirmedPickupAvailableActors_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPutDownTargetWithLocation
// (Net, NetReliable, Native, Event, Protected, HasDefaults, NetClient, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Loc                            (Parm, IsPlainOldData)

void UPickupManagerComponent::ControlClientPutDownTargetWithLocation(class AActor* Target, const struct FVector& Loc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPutDownTargetWithLocation");

	UPickupManagerComponent_ControlClientPutDownTargetWithLocation_Params params;
	params.Target = Target;
	params.Loc = Loc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPutDownTarget
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::ControlClientPutDownTarget(class AActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPutDownTarget");

	UPickupManagerComponent_ControlClientPutDownTarget_Params params;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPickUpTarget
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)

void UPickupManagerComponent::ControlClientPickUpTarget(class AActor* Target, int AdditionalParam)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ControlClientPickUpTarget");

	UPickupManagerComponent_ControlClientPickUpTarget_Params params;
	params.Target = Target;
	params.AdditionalParam = AdditionalParam;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PickupManagerComponent.ClampWorldLocation
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 OutVector                      (Parm, OutParm, IsPlainOldData)

void UPickupManagerComponent::ClampWorldLocation(struct FVector* OutVector)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PickupManagerComponent.ClampWorldLocation");

	UPickupManagerComponent_ClampWorldLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutVector != nullptr)
		*OutVector = params.OutVector;
}


// Function ShadowTrackerExtra.PlaneCharacter.OnRequestImgSuccess
// (Final, Native, Protected)
// Parameters:
// class UTexture2D*              Texture                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 RequestedURL                   (Parm, ZeroConstructor)

void APlaneCharacter::OnRequestImgSuccess(class UTexture2D* Texture, const struct FString& RequestedURL)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlaneCharacter.OnRequestImgSuccess");

	APlaneCharacter_OnRequestImgSuccess_Params params;
	params.Texture = Texture;
	params.RequestedURL = RequestedURL;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlaneCharacter.OnRep_GetHttpPlaneBannerRightImg
// (Final, Native, Protected)

void APlaneCharacter::OnRep_GetHttpPlaneBannerRightImg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlaneCharacter.OnRep_GetHttpPlaneBannerRightImg");

	APlaneCharacter_OnRep_GetHttpPlaneBannerRightImg_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlaneCharacter.OnRep_GetHttpPlaneBannerLeftImg
// (Final, Native, Protected)

void APlaneCharacter::OnRep_GetHttpPlaneBannerLeftImg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlaneCharacter.OnRep_GetHttpPlaneBannerLeftImg");

	APlaneCharacter_OnRep_GetHttpPlaneBannerLeftImg_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlaneCharacter.OnRep_EnableBanner
// (Final, Native, Protected)

void APlaneCharacter::OnRep_EnableBanner()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlaneCharacter.OnRep_EnableBanner");

	APlaneCharacter_OnRep_EnableBanner_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerGunCollosionComp.SetEffect
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// bool                           Visbile                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 EffectLoc                      (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UPlayerGunCollosionComp::SetEffect(bool Visbile, const struct FVector& EffectLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerGunCollosionComp.SetEffect");

	UPlayerGunCollosionComp_SetEffect_Params params;
	params.Visbile = Visbile;
	params.EffectLoc = EffectLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerGunCollosionComp.CheckCollision
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// int                            InFoldFactor                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// struct FVector                 FoldPoint                      (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 FoldNormal                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UPlayerGunCollosionComp::CheckCollision(int InFoldFactor, const struct FVector& FoldPoint, const struct FVector& FoldNormal)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerGunCollosionComp.CheckCollision");

	UPlayerGunCollosionComp_CheckCollision_Params params;
	params.InFoldFactor = InFoldFactor;
	params.FoldPoint = FoldPoint;
	params.FoldNormal = FoldNormal;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.StartOnPlane
// (Final, Native, Public, BlueprintCallable)

void UPlayerSecurityInfoCollector::StartOnPlane()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.StartOnPlane");

	UPlayerSecurityInfoCollector_StartOnPlane_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.PlayerCanJump
// (Final, Native, Public, BlueprintCallable)

void UPlayerSecurityInfoCollector::PlayerCanJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.PlayerCanJump");

	UPlayerSecurityInfoCollector_PlayerCanJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleSyncCircleInfo
// (Final, Native, Protected)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleSyncCircleInfo(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleSyncCircleInfo");

	UPlayerSecurityInfoCollector_HandleSyncCircleInfo_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterSafeZoneTips
// (Final, Native, Protected)
// Parameters:
// float                          SafeZoneTime                   (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterSafeZoneTips(float SafeZoneTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterSafeZoneTips");

	UPlayerSecurityInfoCollector_HandleCharacterSafeZoneTips_Params params;
	params.SafeZoneTime = SafeZoneTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterCircleWaveOver
// (Final, Native, Protected)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterCircleWaveOver(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterCircleWaveOver");

	UPlayerSecurityInfoCollector_HandleCharacterCircleWaveOver_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterCircleSizeAndPosition
// (Final, Native, Protected, HasDefaults)
// Parameters:
// struct FVector                 BlueCircleSync                 (Parm, IsPlainOldData)
// struct FVector                 WhiteCircleSync                (Parm, IsPlainOldData)
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterCircleSizeAndPosition(const struct FVector& BlueCircleSync, const struct FVector& WhiteCircleSync, int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterCircleSizeAndPosition");

	UPlayerSecurityInfoCollector_HandleCharacterCircleSizeAndPosition_Params params;
	params.BlueCircleSync = BlueCircleSync;
	params.WhiteCircleSync = WhiteCircleSync;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterBlueCircleRun
// (Final, Native, Protected)
// Parameters:
// float                          BlueCircleRunTime              (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterBlueCircleRun(float BlueCircleRunTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterBlueCircleRun");

	UPlayerSecurityInfoCollector_HandleCharacterBlueCircleRun_Params params;
	params.BlueCircleRunTime = BlueCircleRunTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterBlueCirclePreWarning
// (Final, Native, Protected)
// Parameters:
// float                          BlueCirclePreWarningTime       (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterBlueCirclePreWarning(float BlueCirclePreWarningTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterBlueCirclePreWarning");

	UPlayerSecurityInfoCollector_HandleCharacterBlueCirclePreWarning_Params params;
	params.BlueCirclePreWarningTime = BlueCirclePreWarningTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterAttrChangedWithDetail
// (Final, Native, Protected)
// Parameters:
// class AActor*                  nowActor                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 AttrName                       (Parm, ZeroConstructor)
// float                          ValueDelta                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          ResultValue                    (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSecurityInfoCollector::HandleCharacterAttrChangedWithDetail(class AActor* nowActor, const struct FString& AttrName, float ValueDelta, float ResultValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.HandleCharacterAttrChangedWithDetail");

	UPlayerSecurityInfoCollector_HandleCharacterAttrChangedWithDetail_Params params;
	params.nowActor = nowActor;
	params.AttrName = AttrName;
	params.ValueDelta = ValueDelta;
	params.ResultValue = ResultValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.ExitParachute
// (Final, Native, Public, BlueprintCallable)

void UPlayerSecurityInfoCollector::ExitParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.ExitParachute");

	UPlayerSecurityInfoCollector_ExitParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.EnterParachute
// (Final, Native, Public, BlueprintCallable)

void UPlayerSecurityInfoCollector::EnterParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.EnterParachute");

	UPlayerSecurityInfoCollector_EnterParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSecurityInfoCollector.EnterJumping
// (Final, Native, Public, BlueprintCallable)

void UPlayerSecurityInfoCollector::EnterJumping()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSecurityInfoCollector.EnterJumping");

	UPlayerSecurityInfoCollector_EnterJumping_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.UpdateSwimMove_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerSwimComponent::UpdateSwimMove_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.UpdateSwimMove_BluePrint");

	UPlayerSwimComponent_UpdateSwimMove_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.UpdateSwimCollisionHeightCpp
// (Final, Native, Public)

void UPlayerSwimComponent::UpdateSwimCollisionHeightCpp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.UpdateSwimCollisionHeightCpp");

	UPlayerSwimComponent_UpdateSwimCollisionHeightCpp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.UpdatePlayerState_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerSwimComponent::UpdatePlayerState_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.UpdatePlayerState_BluePrint");

	UPlayerSwimComponent_UpdatePlayerState_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.UpdateCameraState_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerSwimComponent::UpdateCameraState_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.UpdateCameraState_BluePrint");

	UPlayerSwimComponent_UpdateCameraState_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.UpdateBreath_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerSwimComponent::UpdateBreath_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.UpdateBreath_BluePrint");

	UPlayerSwimComponent_UpdateBreath_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.SyncWaterObject_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerSwimComponent::SyncWaterObject_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.SyncWaterObject_BluePrint");

	UPlayerSwimComponent_SyncWaterObject_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.SetDeltTime_BluePrint
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UPlayerSwimComponent::SetDeltTime_BluePrint(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.SetDeltTime_BluePrint");

	UPlayerSwimComponent_SetDeltTime_BluePrint_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.GetWaterObject
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* UPlayerSwimComponent::GetWaterObject()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.GetWaterObject");

	UPlayerSwimComponent_GetWaterObject_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.CheckCanProne
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UPlayerSwimComponent::CheckCanProne()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.CheckCanProne");

	UPlayerSwimComponent_CheckCanProne_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerSwimComponent.CheckCanCrouch
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UPlayerSwimComponent::CheckCanCrouch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerSwimComponent.CheckCanCrouch");

	UPlayerSwimComponent_CheckCanCrouch_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerTombBox.SwitchToDeadTombBox
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void APlayerTombBox::SwitchToDeadTombBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.SwitchToDeadTombBox");

	APlayerTombBox_SwitchToDeadTombBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.SetVisible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsVisible                      (Parm, ZeroConstructor, IsPlainOldData)

void APlayerTombBox::SetVisible(bool IsVisible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.SetVisible");

	APlayerTombBox_SetVisible_Params params;
	params.IsVisible = IsVisible;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.RegisterToPlayerPickUpList
// (Final, Native, Public, BlueprintCallable)

void APlayerTombBox::RegisterToPlayerPickUpList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.RegisterToPlayerPickUpList");

	APlayerTombBox_RegisterToPlayerPickUpList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.OnRep_VisibilityChange
// (Final, Native, Protected)

void APlayerTombBox::OnRep_VisibilityChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.OnRep_VisibilityChange");

	APlayerTombBox_OnRep_VisibilityChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.OnRep_ChangeBoxMesh
// (Final, Native, Protected)

void APlayerTombBox::OnRep_ChangeBoxMesh()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.OnRep_ChangeBoxMesh");

	APlayerTombBox_OnRep_ChangeBoxMesh_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.OnRep_BoxLifeSpan
// (Final, Native, Protected)

void APlayerTombBox::OnRep_BoxLifeSpan()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.OnRep_BoxLifeSpan");

	APlayerTombBox_OnRep_BoxLifeSpan_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.OnRep_AttachmentReplication
// (Native, Public)

void APlayerTombBox::OnRep_AttachmentReplication()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.OnRep_AttachmentReplication");

	APlayerTombBox_OnRep_AttachmentReplication_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.OnRep_AttachedActor
// (Final, Native, Protected)

void APlayerTombBox::OnRep_AttachedActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.OnRep_AttachedActor");

	APlayerTombBox_OnRep_AttachedActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.HideDeadTombApparence
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void APlayerTombBox::HideDeadTombApparence()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.HideDeadTombApparence");

	APlayerTombBox_HideDeadTombApparence_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.GetTombboxLifespan
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int APlayerTombBox::GetTombboxLifespan()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GetTombboxLifespan");

	APlayerTombBox_GetTombboxLifespan_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerTombBox.GetBoxPickupWrapperActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APickUpListWrapperActor* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APickUpListWrapperActor* APlayerTombBox::GetBoxPickupWrapperActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GetBoxPickupWrapperActor");

	APlayerTombBox_GetBoxPickupWrapperActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerTombBox.GenerateTreasureBoxWrappers
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FAirDropBoxGenerateWrapperItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FName                   AirBoxName                     (Parm, ZeroConstructor, IsPlainOldData)

void APlayerTombBox::GenerateTreasureBoxWrappers(TArray<struct FAirDropBoxGenerateWrapperItemData> DataList, const struct FName& AirBoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GenerateTreasureBoxWrappers");

	APlayerTombBox_GenerateTreasureBoxWrappers_Params params;
	params.DataList = DataList;
	params.AirBoxName = AirBoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.GeneratePlayerBackpackWrappers
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void APlayerTombBox::GeneratePlayerBackpackWrappers()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GeneratePlayerBackpackWrappers");

	APlayerTombBox_GeneratePlayerBackpackWrappers_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersInner
// (Final, Native, Protected, HasOutParms)
// Parameters:
// class UClass*                  WrapperClass                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FPickUpItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FName                   BoxName                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           AttachToBox                    (Parm, ZeroConstructor, IsPlainOldData)
// class APickUpListWrapperActor* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APickUpListWrapperActor* APlayerTombBox::GenerateBoxWrappersInner(class UClass* WrapperClass, TArray<struct FPickUpItemData> DataList, const struct FName& BoxName, bool AttachToBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersInner");

	APlayerTombBox_GenerateBoxWrappersInner_Params params;
	params.WrapperClass = WrapperClass;
	params.DataList = DataList;
	params.BoxName = BoxName;
	params.AttachToBox = AttachToBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersByPickUpItemDataListAndWrapper
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UClass*                  WrapperClass                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FPickUpItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FName                   BoxName                        (Parm, ZeroConstructor, IsPlainOldData)

void APlayerTombBox::GenerateBoxWrappersByPickUpItemDataListAndWrapper(class UClass* WrapperClass, TArray<struct FPickUpItemData> DataList, const struct FName& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersByPickUpItemDataListAndWrapper");

	APlayerTombBox_GenerateBoxWrappersByPickUpItemDataListAndWrapper_Params params;
	params.WrapperClass = WrapperClass;
	params.DataList = DataList;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersByPickUpItemDataList
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FPickUpItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FName                   BoxName                        (Parm, ZeroConstructor, IsPlainOldData)

void APlayerTombBox::GenerateBoxWrappersByPickUpItemDataList(TArray<struct FPickUpItemData> DataList, const struct FName& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GenerateBoxWrappersByPickUpItemDataList");

	APlayerTombBox_GenerateBoxWrappersByPickUpItemDataList_Params params;
	params.DataList = DataList;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerTombBox.GenerateAirDropBoxWrappers
// (Native, Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FAirDropBoxGenerateWrapperItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FName                   AirBoxName                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            AirDropBoxID                   (Parm, ZeroConstructor, IsPlainOldData)

void APlayerTombBox::GenerateAirDropBoxWrappers(TArray<struct FAirDropBoxGenerateWrapperItemData> DataList, const struct FName& AirBoxName, int AirDropBoxID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerTombBox.GenerateAirDropBoxWrappers");

	APlayerTombBox_GenerateAirDropBoxWrappers_Params params;
	params.DataList = DataList;
	params.AirBoxName = AirBoxName;
	params.AirDropBoxID = AirDropBoxID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PlayerVaultComponent.VaultFromCPP
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UPlayerVaultComponent::VaultFromCPP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerVaultComponent.VaultFromCPP");

	UPlayerVaultComponent_VaultFromCPP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PlayerVaultComponent.UpdateVault_BluePrint
// (Native, Event, Public, BlueprintEvent)

void UPlayerVaultComponent::UpdateVault_BluePrint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PlayerVaultComponent.UpdateVault_BluePrint");

	UPlayerVaultComponent_UpdateVault_BluePrint_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.StartDrop
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  DeadCharacter                  (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::StartDrop(class AActor* DeadCharacter, class AController* Killer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.StartDrop");

	UProduceDropItemComponent_StartDrop_Params params;
	params.DeadCharacter = DeadCharacter;
	params.Killer = Killer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.SetProduceID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            produceID                      (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::SetProduceID(int produceID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.SetProduceID");

	UProduceDropItemComponent_SetProduceID_Params params;
	params.produceID = produceID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.PickItemByUnionRandom
// (Final, Native, Protected, HasOutParms, BlueprintCallable)
// Parameters:
// int                            WeightCount                    (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FRandomPropData> WeightMap                      (Parm, OutParm, ZeroConstructor)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UProduceDropItemComponent::PickItemByUnionRandom(int WeightCount, TArray<struct FRandomPropData>* WeightMap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.PickItemByUnionRandom");

	UProduceDropItemComponent_PickItemByUnionRandom_Params params;
	params.WeightCount = WeightCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (WeightMap != nullptr)
		*WeightMap = params.WeightMap;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.PickItemByIndependentRandom
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int                            Weight                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UProduceDropItemComponent::PickItemByIndependentRandom(int Weight)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.PickItemByIndependentRandom");

	UProduceDropItemComponent_PickItemByIndependentRandom_Params params;
	params.Weight = Weight;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.OnOwnerActorDead
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   DeadCharacter                  (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  DamageType                     (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::OnOwnerActorDead(class ASTExtraBaseCharacter* DeadCharacter, class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* DamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.OnOwnerActorDead");

	UProduceDropItemComponent_OnOwnerActorDead_Params params;
	params.DeadCharacter = DeadCharacter;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.DamageType = DamageType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.NineGridDrop
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<struct FPickUpItemData> PropDatas                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FTransform              PawnTrans                      (Parm, IsPlainOldData)
// class AActor*                  IgnorePawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  KillerActor                    (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::NineGridDrop(TArray<struct FPickUpItemData> PropDatas, const struct FTransform& PawnTrans, class AActor* IgnorePawn, class AActor* KillerActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.NineGridDrop");

	UProduceDropItemComponent_NineGridDrop_Params params;
	params.PropDatas = PropDatas;
	params.PawnTrans = PawnTrans;
	params.IgnorePawn = IgnorePawn;
	params.KillerActor = KillerActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.GetWrapperActorPath
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UProduceDropItemComponent::GetWrapperActorPath(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.GetWrapperActorPath");

	UProduceDropItemComponent_GetWrapperActorPath_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.GetWrapperActorClass
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UClass*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UClass* UProduceDropItemComponent::GetWrapperActorClass(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.GetWrapperActorClass");

	UProduceDropItemComponent_GetWrapperActorClass_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.GetDropItemCfgList
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// TArray<struct FDropItemConfig> DropList                       (Parm, OutParm, ZeroConstructor)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UProduceDropItemComponent::GetDropItemCfgList(TArray<struct FDropItemConfig>* DropList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.GetDropItemCfgList");

	UProduceDropItemComponent_GetDropItemCfgList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DropList != nullptr)
		*DropList = params.DropList;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.GenerateDropItemByOwner
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FDropPropData>   FinalDropItems                 (Parm, OutParm, ZeroConstructor)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UProduceDropItemComponent::GenerateDropItemByOwner(TArray<struct FDropPropData>* FinalDropItems)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.GenerateDropItemByOwner");

	UProduceDropItemComponent_GenerateDropItemByOwner_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (FinalDropItems != nullptr)
		*FinalDropItems = params.FinalDropItems;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTreasureBox
// (Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FDropPropData>   PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class AActor*                  TargetActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UProduceDropItemComponent::DropToTreasureBox(TArray<struct FDropPropData> PropData, class AActor* TargetActor, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTreasureBox");

	UProduceDropItemComponent_DropToTreasureBox_Params params;
	params.PropData = PropData;
	params.TargetActor = TargetActor;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTombBox
// (Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FPickUpItemData> PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class ACharacter*              DeadPawn                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)

void UProduceDropItemComponent::DropToTombBox(TArray<struct FPickUpItemData> PropData, class ACharacter* DeadPawn, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTombBox");

	UProduceDropItemComponent_DropToTombBox_Params params;
	params.PropData = PropData;
	params.DeadPawn = DeadPawn;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTarget
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      Backpack                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UProduceDropItemComponent::DropToTarget(const struct FItemDefineID& DefineID, int Count, class UBackpackComponent* Backpack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.DropToTarget");

	UProduceDropItemComponent_DropToTarget_Params params;
	params.DefineID = DefineID;
	params.Count = Count;
	params.Backpack = Backpack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.DropToGround
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPickUpItemData         PropData                       (ConstParm, Parm, OutParm, ReferenceParm)
// struct FTransform              WrapperTrans                   (Parm, IsPlainOldData)
// bool                           ShowGroundEffect               (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::DropToGround(const struct FPickUpItemData& PropData, const struct FTransform& WrapperTrans, bool ShowGroundEffect)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.DropToGround");

	UProduceDropItemComponent_DropToGround_Params params;
	params.PropData = PropData;
	params.WrapperTrans = WrapperTrans;
	params.ShowGroundEffect = ShowGroundEffect;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.DropOutProps
// (Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FDropPropData>   PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class ACharacter*              KillerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DeadPawn                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)

void UProduceDropItemComponent::DropOutProps(TArray<struct FDropPropData> PropData, class ACharacter* KillerPawn, class AActor* DeadPawn, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.DropOutProps");

	UProduceDropItemComponent_DropOutProps_Params params;
	params.PropData = PropData;
	params.KillerPawn = KillerPawn;
	params.DeadPawn = DeadPawn;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.CircleDrop
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<struct FPickUpItemData> PropDatas                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FTransform              PawnTrans                      (Parm, IsPlainOldData)
// class AActor*                  IgnorePawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  KillerActor                    (Parm, ZeroConstructor, IsPlainOldData)

void UProduceDropItemComponent::CircleDrop(TArray<struct FPickUpItemData> PropDatas, const struct FTransform& PawnTrans, class AActor* IgnorePawn, class AActor* KillerActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.CircleDrop");

	UProduceDropItemComponent_CircleDrop_Params params;
	params.PropDatas = PropDatas;
	params.PawnTrans = PawnTrans;
	params.IgnorePawn = IgnorePawn;
	params.KillerActor = KillerActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ProduceDropItemComponent.CalcDropItemListByDropRule
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// struct FDropItemConfig         DropRuleCfg                    (ConstParm, Parm, OutParm, ReferenceParm)
// TArray<struct FDropPropData>   DropItemList                   (Parm, OutParm, ZeroConstructor)

void UProduceDropItemComponent::CalcDropItemListByDropRule(const struct FDropItemConfig& DropRuleCfg, TArray<struct FDropPropData>* DropItemList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ProduceDropItemComponent.CalcDropItemListByDropRule");

	UProduceDropItemComponent_CalcDropItemListByDropRule_Params params;
	params.DropRuleCfg = DropRuleCfg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DropItemList != nullptr)
		*DropItemList = params.DropItemList;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.NineGridDrop
// (Native, Public, HasOutParms, HasDefaults)
// Parameters:
// TArray<struct FPickUpItemData> PropDatas                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FTransform              PawnTrans                      (Parm, IsPlainOldData)
// class AActor*                  ignoreActor                    (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  KillerActor                    (Parm, ZeroConstructor, IsPlainOldData)

void UPropDropOutMethodInterface::NineGridDrop(TArray<struct FPickUpItemData> PropDatas, const struct FTransform& PawnTrans, class AActor* ignoreActor, class AActor* KillerActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.NineGridDrop");

	UPropDropOutMethodInterface_NineGridDrop_Params params;
	params.PropDatas = PropDatas;
	params.PawnTrans = PawnTrans;
	params.ignoreActor = ignoreActor;
	params.KillerActor = KillerActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTreasureBox
// (Native, Public, HasOutParms)
// Parameters:
// TArray<struct FDropPropData>   PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class AActor*                  TargetActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UPropDropOutMethodInterface::DropToTreasureBox(TArray<struct FDropPropData> PropData, class AActor* TargetActor, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTreasureBox");

	UPropDropOutMethodInterface_DropToTreasureBox_Params params;
	params.PropData = PropData;
	params.TargetActor = TargetActor;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTombBox
// (Native, Public, HasOutParms)
// Parameters:
// TArray<struct FPickUpItemData> PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class ACharacter*              DeadPawn                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)

void UPropDropOutMethodInterface::DropToTombBox(TArray<struct FPickUpItemData> PropData, class ACharacter* DeadPawn, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTombBox");

	UPropDropOutMethodInterface_DropToTombBox_Params params;
	params.PropData = PropData;
	params.DeadPawn = DeadPawn;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTarget
// (Native, Public)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      Backpack                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UPropDropOutMethodInterface::DropToTarget(const struct FItemDefineID& DefineID, int Count, class UBackpackComponent* Backpack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToTarget");

	UPropDropOutMethodInterface_DropToTarget_Params params;
	params.DefineID = DefineID;
	params.Count = Count;
	params.Backpack = Backpack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToGround
// (Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FPickUpItemData         PropData                       (ConstParm, Parm, OutParm, ReferenceParm)
// struct FTransform              WrapperTrans                   (Parm, IsPlainOldData)
// bool                           ShowGroundEffect               (Parm, ZeroConstructor, IsPlainOldData)

void UPropDropOutMethodInterface::DropToGround(const struct FPickUpItemData& PropData, const struct FTransform& WrapperTrans, bool ShowGroundEffect)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.DropToGround");

	UPropDropOutMethodInterface_DropToGround_Params params;
	params.PropData = PropData;
	params.WrapperTrans = WrapperTrans;
	params.ShowGroundEffect = ShowGroundEffect;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.DropOutProps
// (Native, Public, HasOutParms)
// Parameters:
// TArray<struct FDropPropData>   PropData                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class ACharacter*              KillerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DeadPawn                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 BoxName                        (Parm, ZeroConstructor)

void UPropDropOutMethodInterface::DropOutProps(TArray<struct FDropPropData> PropData, class ACharacter* KillerPawn, class AActor* DeadPawn, const struct FString& BoxName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.DropOutProps");

	UPropDropOutMethodInterface_DropOutProps_Params params;
	params.PropData = PropData;
	params.KillerPawn = KillerPawn;
	params.DeadPawn = DeadPawn;
	params.BoxName = BoxName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PropDropOutMethodInterface.CircleDrop
// (Native, Public, HasOutParms, HasDefaults)
// Parameters:
// TArray<struct FPickUpItemData> PropDatas                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FTransform              PawnTrans                      (Parm, IsPlainOldData)
// class AActor*                  IgnorePawn                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  KillerActor                    (Parm, ZeroConstructor, IsPlainOldData)

void UPropDropOutMethodInterface::CircleDrop(TArray<struct FPickUpItemData> PropDatas, const struct FTransform& PawnTrans, class AActor* IgnorePawn, class AActor* KillerActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PropDropOutMethodInterface.CircleDrop");

	UPropDropOutMethodInterface_CircleDrop_Params params;
	params.PropDatas = PropDatas;
	params.PawnTrans = PawnTrans;
	params.IgnorePawn = IgnorePawn;
	params.KillerActor = KillerActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.SetDoorBroken
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bExtraDoor                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  brokenCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::SetDoorBroken(bool bExtraDoor, class AActor* brokenCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.SetDoorBroken");

	APUBGDoor_SetDoorBroken_Params params;
	params.bExtraDoor = bExtraDoor;
	params.brokenCauser = brokenCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.RefreshUIOnClient
// (Final, Native, Public, BlueprintCallable)

void APUBGDoor::RefreshUIOnClient()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.RefreshUIOnClient");

	APUBGDoor_RefreshUIOnClient_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.Refresh_DoorIgnore
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           InIsExDoor                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          InDoorAng                      (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::Refresh_DoorIgnore(bool InIsExDoor, float InDoorAng)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.Refresh_DoorIgnore");

	APUBGDoor_Refresh_DoorIgnore_Params params;
	params.InIsExDoor = InIsExDoor;
	params.InDoorAng = InDoorAng;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OpenDoorBy
// (Final, Native, Public)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           extraDoor                      (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::OpenDoorBy(class ACharacter* Character, bool extraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OpenDoorBy");

	APUBGDoor_OpenDoorBy_Params params;
	params.Character = Character;
	params.extraDoor = extraDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorStateEx
// (Final, Native, Public)

void APUBGDoor::OnRep_RepDoorStateEx()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorStateEx");

	APUBGDoor_OnRep_RepDoorStateEx_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorState
// (Final, Native, Public)

void APUBGDoor::OnRep_RepDoorState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorState");

	APUBGDoor_OnRep_RepDoorState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorBrokenEx
// (Final, Native, Public)

void APUBGDoor::OnRep_RepDoorBrokenEx()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorBrokenEx");

	APUBGDoor_OnRep_RepDoorBrokenEx_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorBroken
// (Final, Native, Public)

void APUBGDoor::OnRep_RepDoorBroken()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnRep_RepDoorBroken");

	APUBGDoor_OnRep_RepDoorBroken_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnEndOverlapEx
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::OnEndOverlapEx(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnEndOverlapEx");

	APUBGDoor_OnEndOverlapEx_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnEndOverlap
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::OnEndOverlap(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnEndOverlap");

	APUBGDoor_OnEndOverlap_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnDoorRPC
// (Final, Native, Public)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAimingExtraDoor               (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::OnDoorRPC(class ACharacter* Character, bool bAimingExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnDoorRPC");

	APUBGDoor_OnDoorRPC_Params params;
	params.Character = Character;
	params.bAimingExtraDoor = bAimingExtraDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.PUBGDoor.OnDoorAniFinsihDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// class APUBGDoor*               door                           (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::OnDoorAniFinsihDelegate__DelegateSignature(class APUBGDoor* door)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.PUBGDoor.OnDoorAniFinsihDelegate__DelegateSignature");

	APUBGDoor_OnDoorAniFinsihDelegate__DelegateSignature_Params params;
	params.door = door;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnBeginOverlapEx
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void APUBGDoor::OnBeginOverlapEx(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnBeginOverlapEx");

	APUBGDoor_OnBeginOverlapEx_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.OnBeginOverlap
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void APUBGDoor::OnBeginOverlap(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.OnBeginOverlap");

	APUBGDoor_OnBeginOverlap_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.On_DoorAniFinsih
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBoxComponent*           InDoorCheckBox                 (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           extraDoor                      (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::On_DoorAniFinsih(class UBoxComponent* InDoorCheckBox, bool extraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.On_DoorAniFinsih");

	APUBGDoor_On_DoorAniFinsih_Params params;
	params.InDoorCheckBox = InDoorCheckBox;
	params.extraDoor = extraDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBoxComponent*           interactionBox                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UStaticMeshComponent*    doorMesh                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           inDoubleDoor                   (Parm, ZeroConstructor, IsPlainOldData)
// class UBoxComponent*           interactionBoxEx               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UStaticMeshComponent*    doorMeshEx                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void APUBGDoor::Init(class UBoxComponent* interactionBox, class UStaticMeshComponent* doorMesh, bool inDoubleDoor, class UBoxComponent* interactionBoxEx, class UStaticMeshComponent* doorMeshEx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.Init");

	APUBGDoor_Init_Params params;
	params.interactionBox = interactionBox;
	params.doorMesh = doorMesh;
	params.inDoubleDoor = inDoubleDoor;
	params.interactionBoxEx = interactionBoxEx;
	params.doorMeshEx = doorMeshEx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.ForceNetUpdate
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)

void APUBGDoor::ForceNetUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.ForceNetUpdate");

	APUBGDoor_ForceNetUpdate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.CloseDoorBy
// (Final, Native, Public)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           extraDoor                      (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::CloseDoorBy(class ACharacter* Character, bool extraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.CloseDoorBy");

	APUBGDoor_CloseDoorBy_Params params;
	params.Character = Character;
	params.extraDoor = extraDoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.BP_DoorBroken
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           isBeginPlay                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bExtraDoor                     (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::BP_DoorBroken(bool isBeginPlay, bool bExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.BP_DoorBroken");

	APUBGDoor_BP_DoorBroken_Params params;
	params.isBeginPlay = isBeginPlay;
	params.bExtraDoor = bExtraDoor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.ActionDoorOnClient
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            doorStateDst                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bExtraDoor                     (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::ActionDoorOnClient(int doorStateDst, bool bExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.ActionDoorOnClient");

	APUBGDoor_ActionDoorOnClient_Params params;
	params.doorStateDst = doorStateDst;
	params.bExtraDoor = bExtraDoor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.PUBGDoor.ActionDoorImmediatly
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            doorStateDst                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bExtraDoor                     (Parm, ZeroConstructor, IsPlainOldData)

void APUBGDoor::ActionDoorImmediatly(int doorStateDst, bool bExtraDoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.PUBGDoor.ActionDoorImmediatly");

	APUBGDoor_ActionDoorImmediatly_Params params;
	params.doorStateDst = doorStateDst;
	params.bExtraDoor = bExtraDoor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RadiationCircle.InitRadiationCircle
// (Final, Native, Public)

void ARadiationCircle::InitRadiationCircle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RadiationCircle.InitRadiationCircle");

	ARadiationCircle_InitRadiationCircle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RadiationCircle.HandleOnSafeZoneTips
// (Final, Native, Public)
// Parameters:
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ARadiationCircle::HandleOnSafeZoneTips(float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RadiationCircle.HandleOnSafeZoneTips");

	ARadiationCircle_HandleOnSafeZoneTips_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnRespawned
// (Event, Protected, BlueprintEvent)

void ARecyclableNetActor::ReceiveOnRespawned()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnRespawned");

	ARecyclableNetActor_ReceiveOnRespawned_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnRecycled
// (Event, Protected, BlueprintEvent)

void ARecyclableNetActor::ReceiveOnRecycled()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnRecycled");

	ARecyclableNetActor_ReceiveOnRecycled_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnOwnerChanged
// (Event, Protected, BlueprintEvent)

void ARecyclableNetActor::ReceiveOnOwnerChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RecyclableNetActor.ReceiveOnOwnerChanged");

	ARecyclableNetActor_ReceiveOnOwnerChanged_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RecyclableNetActor.OnRep_Owner
// (Native, Public)

void ARecyclableNetActor::OnRep_Owner()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RecyclableNetActor.OnRep_Owner");

	ARecyclableNetActor_OnRep_Owner_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RespawnRulesComponent.InitRespawnRuleTimer
// (Final, Native, Public)

void URespawnRulesComponent::InitRespawnRuleTimer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RespawnRulesComponent.InitRespawnRuleTimer");

	URespawnRulesComponent_InitRespawnRuleTimer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.RespawnRulesComponent.ApplyRespawnRule
// (Final, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void URespawnRulesComponent::ApplyRespawnRule(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.RespawnRulesComponent.ApplyRespawnRule");

	URespawnRulesComponent_ApplyRespawnRule_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterWeaponStartFire
// (Final, Native, Protected)

void USecurityLogWeaponCollector::OnCharacterWeaponStartFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterWeaponStartFire");

	USecurityLogWeaponCollector_OnCharacterWeaponStartFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterWeaponShootHit
// (Native, Event, Protected, HasOutParms, BlueprintEvent)
// Parameters:
// struct FShootWeaponDamageEvent DamageDetail                   (ConstParm, Parm, OutParm, ReferenceParm)
// struct FBulletHitInfoUploadData HitData                        (ConstParm, Parm, OutParm, ReferenceParm)
// struct FLocalShootHitData      LocalHitData                   (ConstParm, Parm, OutParm, ReferenceParm)

void USecurityLogWeaponCollector::OnCharacterWeaponShootHit(const struct FShootWeaponDamageEvent& DamageDetail, const struct FBulletHitInfoUploadData& HitData, const struct FLocalShootHitData& LocalHitData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterWeaponShootHit");

	USecurityLogWeaponCollector_OnCharacterWeaponShootHit_Params params;
	params.DamageDetail = DamageDetail;
	params.HitData = HitData;
	params.LocalHitData = LocalHitData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterUsingWeaponChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot               (Parm, ZeroConstructor, IsPlainOldData)

void USecurityLogWeaponCollector::OnCharacterUsingWeaponChanged(TEnumAsByte<ESurviveWeaponPropSlot> TargetChangeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterUsingWeaponChanged");

	USecurityLogWeaponCollector_OnCharacterUsingWeaponChanged_Params params;
	params.TargetChangeSlot = TargetChangeSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterShootTarget
// (Native, Event, Protected, HasOutParms, BlueprintEvent)
// Parameters:
// class AActor*                  InHitActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSecurityLogHitTargetInfo TargetInfo                     (ConstParm, Parm, OutParm, ReferenceParm)

void USecurityLogWeaponCollector::OnCharacterShootTarget(class AActor* InHitActor, const struct FSecurityLogHitTargetInfo& TargetInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterShootTarget");

	USecurityLogWeaponCollector_OnCharacterShootTarget_Params params;
	params.InHitActor = InHitActor;
	params.TargetInfo = TargetInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterAimModeChanged
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)

void USecurityLogWeaponCollector::OnCharacterAimModeChanged(TEnumAsByte<EPlayerCameraMode> Mode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.OnCharacterAimModeChanged");

	USecurityLogWeaponCollector_OnCharacterAimModeChanged_Params params;
	params.Mode = Mode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecurityLogWeaponCollector.IsInADSAimState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USecurityLogWeaponCollector::IsInADSAimState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecurityLogWeaponCollector.IsInADSAimState");

	USecurityLogWeaponCollector_IsInADSAimState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportVerifyInfoFlow
// (Net, Native, Event, Public, NetServer, NetValidate)

void USecuryInfoComponent::ReportVerifyInfoFlow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportVerifyInfoFlow");

	USecuryInfoComponent_ReportVerifyInfoFlow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportPlayerKillFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientSecPlayerKillFlow PlayerKillFlow                 (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportPlayerKillFlow(const struct FClientSecPlayerKillFlow& PlayerKillFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportPlayerKillFlow");

	USecuryInfoComponent_ReportPlayerKillFlow_Params params;
	params.PlayerKillFlow = PlayerKillFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportMrpcsFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientSecMrpcsFlow     MrpcsFlow                      (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportMrpcsFlow(const struct FClientSecMrpcsFlow& MrpcsFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportMrpcsFlow");

	USecuryInfoComponent_ReportMrpcsFlow_Params params;
	params.MrpcsFlow = MrpcsFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportJumpFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientJumpFlow         JumpFlow                       (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportJumpFlow(const struct FClientJumpFlow& JumpFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportJumpFlow");

	USecuryInfoComponent_ReportJumpFlow_Params params;
	params.JumpFlow = JumpFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportHurtFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FHurtFlow               HurtFlow                       (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportHurtFlow(const struct FHurtFlow& HurtFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportHurtFlow");

	USecuryInfoComponent_ReportHurtFlow_Params params;
	params.HurtFlow = HurtFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGvoiceTeamQuit
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FGvoiceTeamQuit         teamQuit                       (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGvoiceTeamQuit(const struct FGvoiceTeamQuit& teamQuit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGvoiceTeamQuit");

	USecuryInfoComponent_ReportGvoiceTeamQuit_Params params;
	params.teamQuit = teamQuit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGvoiceTeamCreate
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FGvoiceTeamCreate       teamCreate                     (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGvoiceTeamCreate(const struct FGvoiceTeamCreate& teamCreate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGvoiceTeamCreate");

	USecuryInfoComponent_ReportGvoiceTeamCreate_Params params;
	params.teamCreate = teamCreate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameStartFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientGameStartFlow    GameStartFlow                  (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGameStartFlow(const struct FClientGameStartFlow& GameStartFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameStartFlow");

	USecuryInfoComponent_ReportGameStartFlow_Params params;
	params.GameStartFlow = GameStartFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameSetting
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FGameSetting            GameSetting                    (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGameSetting(const struct FGameSetting& GameSetting)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameSetting");

	USecuryInfoComponent_ReportGameSetting_Params params;
	params.GameSetting = GameSetting;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameEndFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientGameEndFlow      GameEndFlow                    (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGameEndFlow(const struct FClientGameEndFlow& GameEndFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameEndFlow");

	USecuryInfoComponent_ReportGameEndFlow_Params params;
	params.GameEndFlow = GameEndFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameBaseInfo
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FGameBaseInfo           BaseInfo                       (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportGameBaseInfo(const struct FGameBaseInfo& BaseInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportGameBaseInfo");

	USecuryInfoComponent_ReportGameBaseInfo_Params params;
	params.BaseInfo = BaseInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportCircleFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FClientCircleFlow       CircleFlow                     (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportCircleFlow(const struct FClientCircleFlow& CircleFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportCircleFlow");

	USecuryInfoComponent_ReportCircleFlow_Params params;
	params.CircleFlow = CircleFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportAttackFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FAttackFlow             AttackFlow                     (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportAttackFlow(const struct FAttackFlow& AttackFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportAttackFlow");

	USecuryInfoComponent_ReportAttackFlow_Params params;
	params.AttackFlow = AttackFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SecuryInfoComponent.ReportAimFlow
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FAimFlow                AimFlow                        (ConstParm, Parm, ReferenceParm)

void USecuryInfoComponent::ReportAimFlow(const struct FAimFlow& AimFlow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SecuryInfoComponent.ReportAimFlow");

	USecuryInfoComponent_ReportAimFlow_Params params;
	params.AimFlow = AimFlow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.RequireConfigRPC
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void UServerSwitchComponent::RequireConfigRPC()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.RequireConfigRPC");

	UServerSwitchComponent_RequireConfigRPC_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.OnUserQualitySettingChanged
// (Final, Native, Private)
// Parameters:
// int                            renderlevel                    (Parm, ZeroConstructor, IsPlainOldData)

void UServerSwitchComponent::OnUserQualitySettingChanged(int renderlevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.OnUserQualitySettingChanged");

	UServerSwitchComponent_OnUserQualitySettingChanged_Params params;
	params.renderlevel = renderlevel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.MakeLowFPSWarningEx
// (Final, Native, Public, BlueprintCallable)

void UServerSwitchComponent::MakeLowFPSWarningEx()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.MakeLowFPSWarningEx");

	UServerSwitchComponent_MakeLowFPSWarningEx_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.MakeLowFPSWarning
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          targetFPS                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          currentFPS                     (Parm, ZeroConstructor, IsPlainOldData)

void UServerSwitchComponent::MakeLowFPSWarning(float targetFPS, float currentFPS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.MakeLowFPSWarning");

	UServerSwitchComponent_MakeLowFPSWarning_Params params;
	params.targetFPS = targetFPS;
	params.currentFPS = currentFPS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.CountingDown
// (Final, Native, Private)

void UServerSwitchComponent::CountingDown()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.CountingDown");

	UServerSwitchComponent_CountingDown_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.CloseFPSCheck
// (Final, Native, Public, BlueprintCallable)

void UServerSwitchComponent::CloseFPSCheck()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.CloseFPSCheck");

	UServerSwitchComponent_CloseFPSCheck_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ServerSwitchComponent.AnswerconfigRPC
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FFPSMonitorConfigSwitch configswitch                   (Parm)

void UServerSwitchComponent::AnswerconfigRPC(const struct FFPSMonitorConfigSwitch& configswitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ServerSwitchComponent.AnswerconfigRPC");

	UServerSwitchComponent_AnswerconfigRPC_Params params;
	params.configswitch = configswitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShakeComponent.GetVNInstigator_Implementation
// (Final, Native, Public)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* UShakeComponent::GetVNInstigator_Implementation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShakeComponent.GetVNInstigator_Implementation");

	UShakeComponent_GetVNInstigator_Implementation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.ShakeComponent.EndShaking
// (Final, Native, Public)

void UShakeComponent::EndShaking()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShakeComponent.EndShaking");

	UShakeComponent_EndShaking_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.SetUpOrDownOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUp                            (Parm, ZeroConstructor, IsPlainOldData)

void AShootingPracticeTarget::SetUpOrDownOnServer(bool bUp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.SetUpOrDownOnServer");

	AShootingPracticeTarget_SetUpOrDownOnServer_Params params;
	params.bUp = bUp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.RPC_NetMulticast_SetUpOrDownOnServer
// (Net, NetReliable, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// bool                           bUp                            (Parm, ZeroConstructor, IsPlainOldData)

void AShootingPracticeTarget::RPC_NetMulticast_SetUpOrDownOnServer(bool bUp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.RPC_NetMulticast_SetUpOrDownOnServer");

	AShootingPracticeTarget_RPC_NetMulticast_SetUpOrDownOnServer_Params params;
	params.bUp = bUp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.RPC_NetMulticast_NotifyBroken
// (Net, NetReliable, Native, Event, NetMulticast, Protected, NetValidate)

void AShootingPracticeTarget::RPC_NetMulticast_NotifyBroken()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.RPC_NetMulticast_NotifyBroken");

	AShootingPracticeTarget_RPC_NetMulticast_NotifyBroken_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.ResetAndGetUpOnServer
// (Final, Native, Public, BlueprintCallable)

void AShootingPracticeTarget::ResetAndGetUpOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.ResetAndGetUpOnServer");

	AShootingPracticeTarget_ResetAndGetUpOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.OnRep_bIsUp
// (Final, Native, Protected)

void AShootingPracticeTarget::OnRep_bIsUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.OnRep_bIsUp");

	AShootingPracticeTarget_OnRep_bIsUp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.OnRep_bHasActivatedMove
// (Final, Native, Protected)

void AShootingPracticeTarget::OnRep_bHasActivatedMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.OnRep_bHasActivatedMove");

	AShootingPracticeTarget_OnRep_bHasActivatedMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootingPracticeTarget.HandleBroken
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                           bFromClientBeginPlay           (Parm, ZeroConstructor, IsPlainOldData)

void AShootingPracticeTarget::HandleBroken(bool bFromClientBeginPlay)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootingPracticeTarget.HandleBroken");

	AShootingPracticeTarget_HandleBroken_Params params;
	params.bFromClientBeginPlay = bFromClientBeginPlay;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponEffectComponent.HandleWeaponAction
// (Native, Protected)
// Parameters:
// TEnumAsByte<EWeaponAction>     Action                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponEffectComponent::HandleWeaponAction(TEnumAsByte<EWeaponAction> Action)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponEffectComponent.HandleWeaponAction");

	UWeaponEffectComponent_HandleWeaponAction_Params params;
	params.Action = Action;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootWeaponEffectComponent.OnWeaponUnEquiped
// (Final, Native, Protected, BlueprintCallable)

void UShootWeaponEffectComponent::OnWeaponUnEquiped()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootWeaponEffectComponent.OnWeaponUnEquiped");

	UShootWeaponEffectComponent_OnWeaponUnEquiped_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootWeaponEffectComponent.OnWeaponEuiped
// (Final, Native, Protected, BlueprintCallable)

void UShootWeaponEffectComponent::OnWeaponEuiped()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootWeaponEffectComponent.OnWeaponEuiped");

	UShootWeaponEffectComponent_OnWeaponEuiped_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootWeaponEffectComponent.HandleWeaponAction
// (Native, Protected)
// Parameters:
// TEnumAsByte<EWeaponAction>     Action                         (Parm, ZeroConstructor, IsPlainOldData)

void UShootWeaponEffectComponent::HandleWeaponAction(TEnumAsByte<EWeaponAction> Action)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootWeaponEffectComponent.HandleWeaponAction");

	UShootWeaponEffectComponent_HandleWeaponAction_Params params;
	params.Action = Action;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.ShootWeaponEffectComponent.ActiveLocalShellDropFX
// (Final, Native, Public, BlueprintCallable)

void UShootWeaponEffectComponent::ActiveLocalShellDropFX()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.ShootWeaponEffectComponent.ActiveLocalShellDropFX");

	UShootWeaponEffectComponent_ActiveLocalShellDropFX_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponStateManager.GetCurrentState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWeaponStateBase*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UWeaponStateBase* UWeaponStateManager::GetCurrentState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponStateManager.GetCurrentState");

	UWeaponStateManager_GetCurrentState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponStateManager.GetCurrentFreshWeaponStateType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EFreshWeaponStateType> UWeaponStateManager::GetCurrentFreshWeaponStateType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponStateManager.GetCurrentFreshWeaponStateType");

	UWeaponStateManager_GetCurrentFreshWeaponStateType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.SimpleProjectileActor.SetVelocity
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 NewVelocity                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASimpleProjectileActor::SetVelocity(const struct FVector& NewVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimpleProjectileActor.SetVelocity");

	ASimpleProjectileActor_SetVelocity_Params params;
	params.NewVelocity = NewVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnRespawned
// (Event, Protected, BlueprintEvent)

void ASimpleProjectileActor::ReceiveOnRespawned()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnRespawned");

	ASimpleProjectileActor_ReceiveOnRespawned_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnRecycled
// (Event, Protected, BlueprintEvent)

void ASimpleProjectileActor::ReceiveOnRecycled()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnRecycled");

	ASimpleProjectileActor_ReceiveOnRecycled_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnOwnerChanged
// (Event, Protected, BlueprintEvent)

void ASimpleProjectileActor::ReceiveOnOwnerChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimpleProjectileActor.ReceiveOnOwnerChanged");

	ASimpleProjectileActor_ReceiveOnOwnerChanged_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SimpleProjectileActor.OnRep_Owner
// (Native, Public)

void ASimpleProjectileActor::OnRep_Owner()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SimpleProjectileActor.OnRep_Owner");

	ASimpleProjectileActor_OnRep_Owner_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SkillUtils.IsCurUseGrenade
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   pChar                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USkillUtils::IsCurUseGrenade(class ASTExtraBaseCharacter* pChar)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SkillUtils.IsCurUseGrenade");

	USkillUtils_IsCurUseGrenade_Params params;
	params.pChar = pChar;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.SkillUtils.GetPlayerController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APawn*                   OwnerPawn                      (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* USkillUtils::GetPlayerController(class APawn* OwnerPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SkillUtils.GetPlayerController");

	USkillUtils_GetPlayerController_Params params;
	params.OwnerPawn = OwnerPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.SkillUtils.GetParticleComps
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class AActor*                  UserActor                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ParticleTagName                (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UParticleSystemComponent*> OutParArr                      (Parm, OutParm, ZeroConstructor)

void USkillUtils::GetParticleComps(class AActor* UserActor, const struct FName& ParticleTagName, TArray<class UParticleSystemComponent*>* OutParArr)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SkillUtils.GetParticleComps");

	USkillUtils_GetParticleComps_Params params;
	params.UserActor = UserActor;
	params.ParticleTagName = ParticleTagName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutParArr != nullptr)
		*OutParArr = params.OutParArr;
}


// Function ShadowTrackerExtra.SkillUtils.GetMeshCompFromCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   pChar                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   MeshTagName                    (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* USkillUtils::GetMeshCompFromCharacter(class ASTExtraBaseCharacter* pChar, const struct FName& MeshTagName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SkillUtils.GetMeshCompFromCharacter");

	USkillUtils_GetMeshCompFromCharacter_Params params;
	params.pChar = pChar;
	params.MeshTagName = MeshTagName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.SmoothActorMoveComponent.StopMove
// (Final, Native, Public, BlueprintCallable)

void USmoothActorMoveComponent::StopMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SmoothActorMoveComponent.StopMove");

	USmoothActorMoveComponent_StopMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SmoothActorMoveComponent.StartMove
// (Final, Native, Public, BlueprintCallable)

void USmoothActorMoveComponent::StartMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SmoothActorMoveComponent.StartMove");

	USmoothActorMoveComponent_StartMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SRadarChartUserWidget.OnHide
// (Final, Native, Public, BlueprintCallable)

void USRadarChartUserWidget::OnHide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SRadarChartUserWidget.OnHide");

	USRadarChartUserWidget_OnHide_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SRadarChartUserWidget.FreshChartDataToContent
// (Final, Native, Public, BlueprintCallable)

void USRadarChartUserWidget::FreshChartDataToContent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SRadarChartUserWidget.FreshChartDataToContent");

	USRadarChartUserWidget_FreshChartDataToContent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.StatePC_Fight.DelayStopSound
// (Final, Native, Private)

void UStatePC_Fight::DelayStopSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.StatePC_Fight.DelayStopSound");

	UStatePC_Fight_DelayStopSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.StatHUD.ToggleSlateStat
// (Final, Exec, Native, Public)

void AStatHUD::ToggleSlateStat()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.StatHUD.ToggleSlateStat");

	AStatHUD_ToggleSlateStat_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TslDamageField.SetParentGrenade
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ATslDamageField::SetParentGrenade(class AActor* Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TslDamageField.SetParentGrenade");

	ATslDamageField_SetParentGrenade_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TslDamageField.GetParentGrenade
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ATslDamageField::GetParentGrenade()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TslDamageField.GetParentGrenade");

	ATslDamageField_GetParentGrenade_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.TickDamageFields
// (Final, Native, Public)

void ASTBuffApplifierSpreading::TickDamageFields()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.TickDamageFields");

	ASTBuffApplifierSpreading_TickDamageFields_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.SetParentGrenade
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::SetParentGrenade(class AActor* Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.SetParentGrenade");

	ASTBuffApplifierSpreading_SetParentGrenade_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.SetMaxMaterialAdditiveInstanceCount
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::SetMaxMaterialAdditiveInstanceCount(int Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.SetMaxMaterialAdditiveInstanceCount");

	ASTBuffApplifierSpreading_SetMaxMaterialAdditiveInstanceCount_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.SetLastImpactVelocity
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InVelocity                     (Parm, IsPlainOldData)

void ASTBuffApplifierSpreading::SetLastImpactVelocity(const struct FVector& InVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.SetLastImpactVelocity");

	ASTBuffApplifierSpreading_SetLastImpactVelocity_Params params;
	params.InVelocity = InVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.SetInitialEffectLifetime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::SetInitialEffectLifetime(float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.SetInitialEffectLifetime");

	ASTBuffApplifierSpreading_SetInitialEffectLifetime_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.GetParentGrenade
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ASTBuffApplifierSpreading::GetParentGrenade()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.GetParentGrenade");

	ASTBuffApplifierSpreading_GetParentGrenade_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.GetMaxMaterialAdditiveInstanceCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTBuffApplifierSpreading::GetMaxMaterialAdditiveInstanceCount()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.GetMaxMaterialAdditiveInstanceCount");

	ASTBuffApplifierSpreading_GetMaxMaterialAdditiveInstanceCount_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.GetInitialEffectLifetime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTBuffApplifierSpreading::GetInitialEffectLifetime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.GetInitialEffectLifetime");

	ASTBuffApplifierSpreading_GetInitialEffectLifetime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugString
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 InLocation                     (Parm, IsPlainOldData)
// struct FString                 InText                         (Parm, ZeroConstructor)
// class AActor*                  InActor                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::Client_ShowDebugString(const struct FVector& InLocation, const struct FString& InText, class AActor* InActor, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugString");

	ASTBuffApplifierSpreading_Client_ShowDebugString_Params params;
	params.InLocation = InLocation;
	params.InText = InText;
	params.InActor = InActor;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugSphere
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 InLocation                     (Parm, IsPlainOldData)
// float                          InRadius                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::Client_ShowDebugSphere(const struct FVector& InLocation, float InRadius, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugSphere");

	ASTBuffApplifierSpreading_Client_ShowDebugSphere_Params params;
	params.InLocation = InLocation;
	params.InRadius = InRadius;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugLine
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 InStart                        (Parm, IsPlainOldData)
// struct FVector                 InEnd                          (Parm, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTBuffApplifierSpreading::Client_ShowDebugLine(const struct FVector& InStart, const struct FVector& InEnd, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STBuffApplifierSpreading.Client_ShowDebugLine");

	ASTBuffApplifierSpreading_Client_ShowDebugLine_Params params;
	params.InStart = InStart;
	params.InEnd = InEnd;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterFollowComp::WaitingConfirmState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_IsConditionSatisfied");

	USTCharacterFollowComp_WaitingConfirmState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterFollowComp::WaitingConfirmState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_ActOnUnsatisfied");

	USTCharacterFollowComp_WaitingConfirmState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::WaitingConfirmState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.WaitingConfirmState_ActOnSatisfied");

	USTCharacterFollowComp_WaitingConfirmState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.TargetStartVault
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 vaultStartPos                  (Parm, IsPlainOldData)
// class UTargetJumpOperation*    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTargetJumpOperation* USTCharacterFollowComp::TargetStartVault(const struct FVector& vaultStartPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.TargetStartVault");

	USTCharacterFollowComp_TargetStartVault_Params params;
	params.vaultStartPos = vaultStartPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.SetInterruptAutoFollowByInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            InterrupteReason               (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::SetInterruptAutoFollowByInput(int InterrupteReason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.SetInterruptAutoFollowByInput");

	USTCharacterFollowComp_SetInterruptAutoFollowByInput_Params params;
	params.InterrupteReason = InterrupteReason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.SelectedPickedTargetChangeNotifyHUD
// (Final, Native, Public)
// Parameters:
// class APawn*                   previousTarget                 (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::SelectedPickedTargetChangeNotifyHUD(class APawn* previousTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.SelectedPickedTargetChangeNotifyHUD");

	USTCharacterFollowComp_SelectedPickedTargetChangeNotifyHUD_Params params;
	params.previousTarget = previousTarget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.PlayerStopFollow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterFollowComp::PlayerStopFollow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.PlayerStopFollow");

	USTCharacterFollowComp_PlayerStopFollow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.PlayerConfirmToFollow
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterFollowComp::PlayerConfirmToFollow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.PlayerConfirmToFollow");

	USTCharacterFollowComp_PlayerConfirmToFollow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.InitializeOwner
// (Final, Native, Public)
// Parameters:
// class APawn*                   _TempPawn                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::InitializeOwner(class APawn* _TempPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.InitializeOwner");

	USTCharacterFollowComp_InitializeOwner_Params params;
	params._TempPawn = _TempPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.FollowingTargetChangeNotifyHUD
// (Final, Native, Public)
// Parameters:
// class APawn*                   previousTarget                 (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::FollowingTargetChangeNotifyHUD(class APawn* previousTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.FollowingTargetChangeNotifyHUD");

	USTCharacterFollowComp_FollowingTargetChangeNotifyHUD_Params params;
	params.previousTarget = previousTarget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterFollowComp::FollowingState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_IsConditionSatisfied");

	USTCharacterFollowComp_FollowingState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterFollowComp::FollowingState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_ActOnUnsatisfied");

	USTCharacterFollowComp_FollowingState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterFollowComp::FollowingState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterFollowComp.FollowingState_ActOnSatisfied");

	USTCharacterFollowComp_FollowingState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingFroAcceptState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterGiftGiverComp::WaitingFroAcceptState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingFroAcceptState_ActOnSatisfied");

	USTCharacterGiftGiverComp_WaitingFroAcceptState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingForAcceptState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterGiftGiverComp::WaitingForAcceptState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingForAcceptState_ActOnUnsatisfied");

	USTCharacterGiftGiverComp_WaitingForAcceptState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingConfirmState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::WaitingConfirmState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.WaitingConfirmState_IsConditionSatisfied");

	USTCharacterGiftGiverComp_WaitingConfirmState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.TickGiveComp
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterGiftGiverComp::TickGiveComp(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.TickGiveComp");

	USTCharacterGiftGiverComp_TickGiveComp_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.SetGiftGivingDuration
// (Final, Native, Public)
// Parameters:
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterGiftGiverComp::SetGiftGivingDuration(float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.SetGiftGivingDuration");

	USTCharacterGiftGiverComp_SetGiftGivingDuration_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.ReceiverConfirmReceiving
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::ReceiverConfirmReceiving()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.ReceiverConfirmReceiving");

	USTCharacterGiftGiverComp_ReceiverConfirmReceiving_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.ReceiverAccept
// (Final, Native, Public)

void USTCharacterGiftGiverComp::ReceiverAccept()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.ReceiverAccept");

	USTCharacterGiftGiverComp_ReceiverAccept_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.PickTargetsAsReceiver
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<class ASTExtraBaseCharacter*> pickedTargets                  (Parm, OutParm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::PickTargetsAsReceiver(TArray<class ASTExtraBaseCharacter*>* pickedTargets)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.PickTargetsAsReceiver");

	USTCharacterGiftGiverComp_PickTargetsAsReceiver_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (pickedTargets != nullptr)
		*pickedTargets = params.pickedTargets;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.MyReceiverReceivingStateInterrupted
// (Final, Native, Public)

void USTCharacterGiftGiverComp::MyReceiverReceivingStateInterrupted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.MyReceiverReceivingStateInterrupted");

	USTCharacterGiftGiverComp_MyReceiverReceivingStateInterrupted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.IsGiftGivingStatus
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::IsGiftGivingStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.IsGiftGivingStatus");

	USTCharacterGiftGiverComp_IsGiftGivingStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.IsGiftCanGiveStatus
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::IsGiftCanGiveStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.IsGiftCanGiveStatus");

	USTCharacterGiftGiverComp_IsGiftCanGiveStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.InitializeOwner
// (Final, Native, Public)
// Parameters:
// class APawn*                   _TempPawn                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterGiftGiverComp::InitializeOwner(class APawn* _TempPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.InitializeOwner");

	USTCharacterGiftGiverComp_InitializeOwner_Params params;
	params._TempPawn = _TempPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterGiftGiverComp::InGivingState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_IsConditionSatisfied");

	USTCharacterGiftGiverComp_InGivingState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterGiftGiverComp::InGivingState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_ActOnUnsatisfied");

	USTCharacterGiftGiverComp_InGivingState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterGiftGiverComp::InGivingState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.InGivingState_ActOnSatisfied");

	USTCharacterGiftGiverComp_InGivingState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.GivingStateInterrupted
// (Final, Native, Public)

void USTCharacterGiftGiverComp::GivingStateInterrupted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.GivingStateInterrupted");

	USTCharacterGiftGiverComp_GivingStateInterrupted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.GivingFinished
// (Final, Native, Public)

void USTCharacterGiftGiverComp::GivingFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.GivingFinished");

	USTCharacterGiftGiverComp_GivingFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.GetGivingStatusDuration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterGiftGiverComp::GetGivingStatusDuration()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.GetGivingStatusDuration");

	USTCharacterGiftGiverComp_GetGivingStatusDuration_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterGiftGiverComp.CanGiveStateInterrupted
// (Final, Native, Public)

void USTCharacterGiftGiverComp::CanGiveStateInterrupted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterGiftGiverComp.CanGiveStateInterrupted");

	USTCharacterGiftGiverComp_CanGiveStateInterrupted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ToggleUserCmdDelta
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::ToggleUserCmdDelta(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ToggleUserCmdDelta");

	USTCharacterMovementComponent_ToggleUserCmdDelta_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.TimeSpeedCheck
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::TimeSpeedCheck(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.TimeSpeedCheck");

	USTCharacterMovementComponent_TimeSpeedCheck_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.SeverAddRotationVelocity
// (Net, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 RotationVelocity               (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void USTCharacterMovementComponent::SeverAddRotationVelocity(const struct FVector& RotationVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.SeverAddRotationVelocity");

	USTCharacterMovementComponent_SeverAddRotationVelocity_Params params;
	params.RotationVelocity = RotationVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.SetProneFloorZ
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          InProneFloorZ                  (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::SetProneFloorZ(float InProneFloorZ)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.SetProneFloorZ");

	USTCharacterMovementComponent_SetProneFloorZ_Params params;
	params.InProneFloorZ = InProneFloorZ;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.SetProneFloorAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          InProneFloorAngle              (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::SetProneFloorAngle(float InProneFloorAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.SetProneFloorAngle");

	USTCharacterMovementComponent_SetProneFloorAngle_Params params;
	params.InProneFloorAngle = InProneFloorAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.SetJumpFloorZ
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          InJumpFloorZ                   (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::SetJumpFloorZ(float InJumpFloorZ)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.SetJumpFloorZ");

	USTCharacterMovementComponent_SetJumpFloorZ_Params params;
	params.InJumpFloorZ = InJumpFloorZ;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.SetJumpFloorAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          InJumpFloorAngle               (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::SetJumpFloorAngle(float InJumpFloorAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.SetJumpFloorAngle");

	USTCharacterMovementComponent_SetJumpFloorAngle_Params params;
	params.InJumpFloorAngle = InJumpFloorAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmdOld
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            ClientApplySequence            (Parm, ZeroConstructor, IsPlainOldData)
// TArray<unsigned char>          UserCmdDelta                   (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void USTCharacterMovementComponent::ServerUserMoveCmdOld(int ClientApplySequence, TArray<unsigned char> UserCmdDelta)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmdOld");

	USTCharacterMovementComponent_ServerUserMoveCmdOld_Params params;
	params.ClientApplySequence = ClientApplySequence;
	params.UserCmdDelta = UserCmdDelta;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmdDual
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// uint32_t                       Sequence                       (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       Checksum                       (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     ClientMovementBase             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<unsigned char>          UserCmd                        (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// TArray<unsigned char>          UserCmdDelta                   (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void USTCharacterMovementComponent::ServerUserMoveCmdDual(uint32_t Sequence, uint32_t Checksum, class UPrimitiveComponent* ClientMovementBase, TArray<unsigned char> UserCmd, TArray<unsigned char> UserCmdDelta)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmdDual");

	USTCharacterMovementComponent_ServerUserMoveCmdDual_Params params;
	params.Sequence = Sequence;
	params.Checksum = Checksum;
	params.ClientMovementBase = ClientMovementBase;
	params.UserCmd = UserCmd;
	params.UserCmdDelta = UserCmdDelta;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmd
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// uint32_t                       Sequence                       (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       Checksum                       (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     ClientMovementBase             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<unsigned char>          UserCmd                        (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void USTCharacterMovementComponent::ServerUserMoveCmd(uint32_t Sequence, uint32_t Checksum, class UPrimitiveComponent* ClientMovementBase, TArray<unsigned char> UserCmd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ServerUserMoveCmd");

	USTCharacterMovementComponent_ServerUserMoveCmd_Params params;
	params.Sequence = Sequence;
	params.Checksum = Checksum;
	params.ClientMovementBase = ClientMovementBase;
	params.UserCmd = UserCmd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.Ping2Server
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// float                          ServerTime                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          ClientTime                     (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::Ping2Server(float ServerTime, float ClientTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.Ping2Server");

	USTCharacterMovementComponent_Ping2Server_Params params;
	params.ServerTime = ServerTime;
	params.ClientTime = ClientTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.Ping2Client
// (Net, Native, Event, Public, NetClient)
// Parameters:
// float                          ServerTime                     (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::Ping2Client(float ServerTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.Ping2Client");

	USTCharacterMovementComponent_Ping2Client_Params params;
	params.ServerTime = ServerTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.PhysicsFlyDistance
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 flyVelocity                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void USTCharacterMovementComponent::PhysicsFlyDistance(float DeltaTime, const struct FVector& flyVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.PhysicsFlyDistance");

	USTCharacterMovementComponent_PhysicsFlyDistance_Params params;
	params.DeltaTime = DeltaTime;
	params.flyVelocity = flyVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.OnRecoverOnServer
// (Native, Public)

void USTCharacterMovementComponent::OnRecoverOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.OnRecoverOnServer");

	USTCharacterMovementComponent_OnRecoverOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.OnPreReconnectOnServer
// (Final, Native, Public)

void USTCharacterMovementComponent::OnPreReconnectOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.OnPreReconnectOnServer");

	USTCharacterMovementComponent_OnPreReconnectOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.OnClientCloseUserCmdDelta
// (Net, NetReliable, Native, Event, Public, NetClient)

void USTCharacterMovementComponent::OnClientCloseUserCmdDelta()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.OnClientCloseUserCmdDelta");

	USTCharacterMovementComponent_OnClientCloseUserCmdDelta_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetProneFloorZ
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterMovementComponent::K2_GetProneFloorZ()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetProneFloorZ");

	USTCharacterMovementComponent_K2_GetProneFloorZ_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetProneFloorAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterMovementComponent::K2_GetProneFloorAngle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetProneFloorAngle");

	USTCharacterMovementComponent_K2_GetProneFloorAngle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetJumpFloorZ
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterMovementComponent::K2_GetJumpFloorZ()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetJumpFloorZ");

	USTCharacterMovementComponent_K2_GetJumpFloorZ_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetJumpFloorAngle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterMovementComponent::K2_GetJumpFloorAngle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.K2_GetJumpFloorAngle");

	USTCharacterMovementComponent_K2_GetJumpFloorAngle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.IsWalkable
// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterMovementComponent::IsWalkable(const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.IsWalkable");

	USTCharacterMovementComponent_IsWalkable_Params params;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.IsProning
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterMovementComponent::IsProning()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.IsProning");

	USTCharacterMovementComponent_IsProning_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.GetSTCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* USTCharacterMovementComponent::GetSTCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.GetSTCharacter");

	USTCharacterMovementComponent_GetSTCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.GetLastServerMoveTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterMovementComponent::GetLastServerMoveTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.GetLastServerMoveTime");

	USTCharacterMovementComponent_GetLastServerMoveTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.DragOnGround
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterMovementComponent::DragOnGround(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.DragOnGround");

	USTCharacterMovementComponent_DragOnGround_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ClientVeryShortAdjustPositionAndRotation
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NewLoc                         (Parm, IsPlainOldData)
// struct FRotator                NewRot                         (Parm, IsPlainOldData)
// class UPrimitiveComponent*     NewBase                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   NewBaseBoneName                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bHasBase                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bBaseRelativePosition          (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  ServerMovementMode             (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::ClientVeryShortAdjustPositionAndRotation(float TimeStamp, const struct FVector& NewLoc, const struct FRotator& NewRot, class UPrimitiveComponent* NewBase, const struct FName& NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ClientVeryShortAdjustPositionAndRotation");

	USTCharacterMovementComponent_ClientVeryShortAdjustPositionAndRotation_Params params;
	params.TimeStamp = TimeStamp;
	params.NewLoc = NewLoc;
	params.NewRot = NewRot;
	params.NewBase = NewBase;
	params.NewBaseBoneName = NewBaseBoneName;
	params.bHasBase = bHasBase;
	params.bBaseRelativePosition = bBaseRelativePosition;
	params.ServerMovementMode = ServerMovementMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ClientUserMoveCmdAck
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// int                            Sequence                       (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::ClientUserMoveCmdAck(int Sequence)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ClientUserMoveCmdAck");

	USTCharacterMovementComponent_ClientUserMoveCmdAck_Params params;
	params.Sequence = Sequence;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ClientAdjustPositionAndRotation
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NewLoc                         (Parm, IsPlainOldData)
// struct FRotator                NewRot                         (Parm, IsPlainOldData)
// struct FVector                 NewVel                         (Parm, IsPlainOldData)
// class UPrimitiveComponent*     NewBase                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   NewBaseBoneName                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bHasBase                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bBaseRelativePosition          (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  ServerMovementMode             (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterMovementComponent::ClientAdjustPositionAndRotation(float TimeStamp, const struct FVector& NewLoc, const struct FRotator& NewRot, const struct FVector& NewVel, class UPrimitiveComponent* NewBase, const struct FName& NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ClientAdjustPositionAndRotation");

	USTCharacterMovementComponent_ClientAdjustPositionAndRotation_Params params;
	params.TimeStamp = TimeStamp;
	params.NewLoc = NewLoc;
	params.NewRot = NewRot;
	params.NewVel = NewVel;
	params.NewBase = NewBase;
	params.NewBaseBoneName = NewBaseBoneName;
	params.bHasBase = bHasBase;
	params.bBaseRelativePosition = bBaseRelativePosition;
	params.ServerMovementMode = ServerMovementMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterMovementComponent.ChangePhysxShapeFlag
// (Final, Native, Public, BlueprintCallable)

void USTCharacterMovementComponent::ChangePhysxShapeFlag()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterMovementComponent.ChangePhysxShapeFlag");

	USTCharacterMovementComponent_ChangePhysxShapeFlag_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.SetHealthSafety
// (Final, Native, Public)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterNearDeathComp::SetHealthSafety(float AddVal)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.SetHealthSafety");

	USTCharacterNearDeathComp_SetHealthSafety_Params params;
	params.AddVal = AddVal;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.S2C_HelpOther
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ACharacter*              HelpWho                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurnInfo                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingRescueTime            (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterNearDeathComp::S2C_HelpOther(class ACharacter* HelpWho, bool IsTurnInfo, float RemainingRescueTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.S2C_HelpOther");

	USTCharacterNearDeathComp_S2C_HelpOther_Params params;
	params.HelpWho = HelpWho;
	params.IsTurnInfo = IsTurnInfo;
	params.RemainingRescueTime = RemainingRescueTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.S2C_BeHelpedByOther
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// class ACharacter*              ByWho                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTurnInfo                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainingRescueTime            (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterNearDeathComp::S2C_BeHelpedByOther(class ACharacter* ByWho, bool IsTurnInfo, float RemainingRescueTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.S2C_BeHelpedByOther");

	USTCharacterNearDeathComp_S2C_BeHelpedByOther_Params params;
	params.ByWho = ByWho;
	params.IsTurnInfo = IsTurnInfo;
	params.RemainingRescueTime = RemainingRescueTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.RescueFinishSuccessfully
// (Final, Native, Public)

void USTCharacterNearDeathComp::RescueFinishSuccessfully()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.RescueFinishSuccessfully");

	USTCharacterNearDeathComp_RescueFinishSuccessfully_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.OnRep_BreathChanged
// (Final, Native, Public)

void USTCharacterNearDeathComp::OnRep_BreathChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.OnRep_BreathChanged");

	USTCharacterNearDeathComp_OnRep_BreathChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.IsNearDeathInvincible
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterNearDeathComp::IsNearDeathInvincible()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.IsNearDeathInvincible");

	USTCharacterNearDeathComp_IsNearDeathInvincible_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.IsHealthAlive
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterNearDeathComp::IsHealthAlive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.IsHealthAlive");

	USTCharacterNearDeathComp_IsHealthAlive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.IsHaveLastBreathStatus
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterNearDeathComp::IsHaveLastBreathStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.IsHaveLastBreathStatus");

	USTCharacterNearDeathComp_IsHaveLastBreathStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.IsFinishedLastBreathStatus
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterNearDeathComp::IsFinishedLastBreathStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.IsFinishedLastBreathStatus");

	USTCharacterNearDeathComp_IsFinishedLastBreathStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.InitializeOwner
// (Final, Native, Public)
// Parameters:
// class APawn*                   TempPawn                       (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterNearDeathComp::InitializeOwner(class APawn* TempPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.InitializeOwner");

	USTCharacterNearDeathComp_InitializeOwner_Params params;
	params.TempPawn = TempPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.GotoLastBreathStatus
// (Final, Native, Public)
// Parameters:
// class AController*             EventInstigator                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (Parm)
// float                          _finalDamage                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsDamageFromVehicleExplode     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterNearDeathComp::GotoLastBreathStatus(class AController* EventInstigator, class AActor* DamageCauser, const struct FDamageEvent& DamageEvent, float _finalDamage, bool IsDamageFromVehicleExplode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.GotoLastBreathStatus");

	USTCharacterNearDeathComp_GotoLastBreathStatus_Params params;
	params.EventInstigator = EventInstigator;
	params.DamageCauser = DamageCauser;
	params.DamageEvent = DamageEvent;
	params._finalDamage = _finalDamage;
	params.IsDamageFromVehicleExplode = IsDamageFromVehicleExplode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.GetBreathMax
// (Final, Native, Public, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterNearDeathComp::GetBreathMax()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.GetBreathMax");

	USTCharacterNearDeathComp_GetBreathMax_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.GetBreath
// (Final, Native, Public, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterNearDeathComp::GetBreath()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.GetBreath");

	USTCharacterNearDeathComp_GetBreath_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.EnterSwimWhileDying
// (Final, Native, Public, BlueprintCallable)

void USTCharacterNearDeathComp::EnterSwimWhileDying()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.EnterSwimWhileDying");

	USTCharacterNearDeathComp_EnterSwimWhileDying_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.DoFinishLastBreath
// (Final, Native, Public)

void USTCharacterNearDeathComp::DoFinishLastBreath()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.DoFinishLastBreath");

	USTCharacterNearDeathComp_DoFinishLastBreath_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.ClearNearDeathTeammate
// (Final, Native, Public)

void USTCharacterNearDeathComp::ClearNearDeathTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.ClearNearDeathTeammate");

	USTCharacterNearDeathComp_ClearNearDeathTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.AddHealthSafety
// (Final, Native, Public)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ForceIgnoreInvinceTime         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterNearDeathComp::AddHealthSafety(float AddVal, bool ForceIgnoreInvinceTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.AddHealthSafety");

	USTCharacterNearDeathComp_AddHealthSafety_Params params;
	params.AddVal = AddVal;
	params.ForceIgnoreInvinceTime = ForceIgnoreInvinceTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterNearDeathComp.AddDeadBuff
// (Final, Native, Public)

void USTCharacterNearDeathComp::AddDeadBuff()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterNearDeathComp.AddDeadBuff");

	USTCharacterNearDeathComp_AddDeadBuff_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterRescueOtherComp::WaitingConfirmState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_IsConditionSatisfied");

	USTCharacterRescueOtherComp_WaitingConfirmState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterRescueOtherComp::WaitingConfirmState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_ActOnUnsatisfied");

	USTCharacterRescueOtherComp_WaitingConfirmState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterRescueOtherComp::WaitingConfirmState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.WaitingConfirmState_ActOnSatisfied");

	USTCharacterRescueOtherComp_WaitingConfirmState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.TickAsHelper
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterRescueOtherComp::TickAsHelper(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.TickAsHelper");

	USTCharacterRescueOtherComp_TickAsHelper_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.ServerPlayerConfirm
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   _RescueWho                     (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterRescueOtherComp::ServerPlayerConfirm(class ASTExtraBaseCharacter* _RescueWho)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.ServerPlayerConfirm");

	USTCharacterRescueOtherComp_ServerPlayerConfirm_Params params;
	params._RescueWho = _RescueWho;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.SelectedPickedTargetChangeNotifyHUD
// (Final, Native, Public)
// Parameters:
// class APawn*                   previousTarget                 (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterRescueOtherComp::SelectedPickedTargetChangeNotifyHUD(class APawn* previousTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.SelectedPickedTargetChangeNotifyHUD");

	USTCharacterRescueOtherComp_SelectedPickedTargetChangeNotifyHUD_Params params;
	params.previousTarget = previousTarget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_IsConditionSatisfied
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterRescueOtherComp::RescueingState_IsConditionSatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_IsConditionSatisfied");

	USTCharacterRescueOtherComp_RescueingState_IsConditionSatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_ActOnUnsatisfied
// (Final, Native, Public)

void USTCharacterRescueOtherComp::RescueingState_ActOnUnsatisfied()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_ActOnUnsatisfied");

	USTCharacterRescueOtherComp_RescueingState_ActOnUnsatisfied_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_ActOnSatisfied
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTCharacterRescueOtherComp::RescueingState_ActOnSatisfied(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingState_ActOnSatisfied");

	USTCharacterRescueOtherComp_RescueingState_ActOnSatisfied_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingProcessFinished
// (Final, Native, Private)

void USTCharacterRescueOtherComp::RescueingProcessFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.RescueingProcessFinished");

	USTCharacterRescueOtherComp_RescueingProcessFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.PlayerConfirmToRescueClientSide
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterRescueOtherComp::PlayerConfirmToRescueClientSide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.PlayerConfirmToRescueClientSide");

	USTCharacterRescueOtherComp_PlayerConfirmToRescueClientSide_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.PickTargetsAsHelper
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<class ASTExtraBaseCharacter*> pickedTargets                  (Parm, OutParm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterRescueOtherComp::PickTargetsAsHelper(TArray<class ASTExtraBaseCharacter*>* pickedTargets)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.PickTargetsAsHelper");

	USTCharacterRescueOtherComp_PickTargetsAsHelper_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (pickedTargets != nullptr)
		*pickedTargets = params.pickedTargets;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.OnRep_IsRescueingOtherStatusChange
// (Final, Native, Public)

void USTCharacterRescueOtherComp::OnRep_IsRescueingOtherStatusChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.OnRep_IsRescueingOtherStatusChange");

	USTCharacterRescueOtherComp_OnRep_IsRescueingOtherStatusChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.IsInRescueingStatus
// (Final, Native, Public, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTCharacterRescueOtherComp::IsInRescueingStatus()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.IsInRescueingStatus");

	USTCharacterRescueOtherComp_IsInRescueingStatus_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.InitializeOwner
// (Final, Native, Public)
// Parameters:
// class APawn*                   _TempPawn                      (Parm, ZeroConstructor, IsPlainOldData)
// class USTCharacterNearDeathComp* _Outer                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void USTCharacterRescueOtherComp::InitializeOwner(class APawn* _TempPawn, class USTCharacterNearDeathComp* _Outer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.InitializeOwner");

	USTCharacterRescueOtherComp_InitializeOwner_Params params;
	params._TempPawn = _TempPawn;
	params._Outer = _Outer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.GetRestoringDuration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTCharacterRescueOtherComp::GetRestoringDuration()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.GetRestoringDuration");

	USTCharacterRescueOtherComp_GetRestoringDuration_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STCharacterRescueOtherComp.DrawDebugFan
// (Final, Native, Private)

void USTCharacterRescueOtherComp::DrawDebugFan()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STCharacterRescueOtherComp.DrawDebugFan");

	USTCharacterRescueOtherComp_DrawDebugFan_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STEActorCacheComponent.PushActorToPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EActorCacheID>     ID                             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTECachableActor*       Target                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTEActorCacheComponent::PushActorToPool(TEnumAsByte<EActorCacheID> ID, class ASTECachableActor* Target)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STEActorCacheComponent.PushActorToPool");

	USTEActorCacheComponent_PushActorToPool_Params params;
	params.ID = ID;
	params.Target = Target;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STEActorCacheComponent.GetActorFromPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EActorCacheID>     ID                             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTECachableActor*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTECachableActor* USTEActorCacheComponent::GetActorFromPool(TEnumAsByte<EActorCacheID> ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STEActorCacheComponent.GetActorFromPool");

	USTEActorCacheComponent_GetActorFromPool_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STECachableActor.RegisterCachePool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USTEActorCacheComponent* Pool                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void ASTECachableActor::RegisterCachePool(class USTEActorCacheComponent* Pool)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STECachableActor.RegisterCachePool");

	ASTECachableActor_RegisterCachePool_Params params;
	params.Pool = Pool;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STECachableActor.PushToPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EActorCacheID>     ID                             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTECachableActor::PushToPool(TEnumAsByte<EActorCacheID> ID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STECachableActor.PushToPool");

	ASTECachableActor_PushToPool_Params params;
	params.ID = ID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.ShootDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void USTExtraShootWeaponComponent::ShootDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.ShootDelegate__DelegateSignature");

	USTExtraShootWeaponComponent_ShootDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeaponComponent.OnWeaponClipMaxBulletChanged
// (Final, Native, Public)

void USTExtraShootWeaponComponent::OnWeaponClipMaxBulletChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeaponComponent.OnWeaponClipMaxBulletChanged");

	USTExtraShootWeaponComponent_OnWeaponClipMaxBulletChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeaponComponent.OnWeaponBulletChanged
// (Final, Native, Protected)

void USTExtraShootWeaponComponent::OnWeaponBulletChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeaponComponent.OnWeaponBulletChanged");

	USTExtraShootWeaponComponent_OnWeaponBulletChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.OnContinuousShootStateChangedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           bIsContinuousShooting          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraShootWeaponComponent::OnContinuousShootStateChangedDelegate__DelegateSignature(bool bIsContinuousShooting)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.OnContinuousShootStateChangedDelegate__DelegateSignature");

	USTExtraShootWeaponComponent_OnContinuousShootStateChangedDelegate__DelegateSignature_Params params;
	params.bIsContinuousShooting = bIsContinuousShooting;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.OnContinuousShootDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            BulletsNum                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraShootWeaponComponent::OnContinuousShootDelegate__DelegateSignature(int BulletsNum)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponComponent.OnContinuousShootDelegate__DelegateSignature");

	USTExtraShootWeaponComponent_OnContinuousShootDelegate__DelegateSignature_Params params;
	params.BulletsNum = BulletsNum;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STEShootWeaponBulletImpactEffect.TimerHideDecal
// (Final, Native, Public)

void ASTEShootWeaponBulletImpactEffect::TimerHideDecal()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STEShootWeaponBulletImpactEffect.TimerHideDecal");

	ASTEShootWeaponBulletImpactEffect_TimerHideDecal_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.SwitchCameraFromBP
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FCameraSettings         CameraSetting                  (Parm, OutParm)

void ASTExtraAirborne::SwitchCameraFromBP(struct FCameraSettings* CameraSetting)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.SwitchCameraFromBP");

	ASTExtraAirborne_SwitchCameraFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (CameraSetting != nullptr)
		*CameraSetting = params.CameraSetting;
}


// Function ShadowTrackerExtra.STExtraAirborne.StateChangeServerFromBP
// (Final, Native, Public)

void ASTExtraAirborne::StateChangeServerFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.StateChangeServerFromBP");

	ASTExtraAirborne_StateChangeServerFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.StateChangeClientFromBP
// (Final, Native, Public)

void ASTExtraAirborne::StateChangeClientFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.StateChangeClientFromBP");

	ASTExtraAirborne_StateChangeClientFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.ServerSetStateFromBP
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// TEnumAsByte<EAirborne2>        AirborneStateBP                (ConstParm, Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::ServerSetStateFromBP(TEnumAsByte<EAirborne2> AirborneStateBP)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.ServerSetStateFromBP");

	ASTExtraAirborne_ServerSetStateFromBP_Params params;
	params.AirborneStateBP = AirborneStateBP;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.ServerAndAirbornAfterLand
// (Event, Public, BlueprintEvent)

void ASTExtraAirborne::ServerAndAirbornAfterLand()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.ServerAndAirbornAfterLand");

	ASTExtraAirborne_ServerAndAirbornAfterLand_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.RotateMulticastFromBP
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable, NetValidate)
// Parameters:
// struct FRotator                Rotator                        (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraAirborne::RotateMulticastFromBP(const struct FRotator& Rotator)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.RotateMulticastFromBP");

	ASTExtraAirborne_RotateMulticastFromBP_Params params;
	params.Rotator = Rotator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.OnStateChangeServerFromBP
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraAirborne::OnStateChangeServerFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.OnStateChangeServerFromBP");

	ASTExtraAirborne_OnStateChangeServerFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.OnStateChangeMultiCastFromBP
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)

void ASTExtraAirborne::OnStateChangeMultiCastFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.OnStateChangeMultiCastFromBP");

	ASTExtraAirborne_OnStateChangeMultiCastFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.OnRep_AirbornStateChange
// (Final, Native, Public, BlueprintCallable)

void ASTExtraAirborne::OnRep_AirbornStateChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.OnRep_AirbornStateChange");

	ASTExtraAirborne_OnRep_AirbornStateChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.OnCameraSettingLerp
// (Final, Native, Public)
// Parameters:
// float                          LerpAlpha                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::OnCameraSettingLerp(float LerpAlpha)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.OnCameraSettingLerp");

	ASTExtraAirborne_OnCameraSettingLerp_Params params;
	params.LerpAlpha = LerpAlpha;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.NormalSpeedFromBP
// (Final, Native, Private, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraAirborne::NormalSpeedFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.NormalSpeedFromBP");

	ASTExtraAirborne_NormalSpeedFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraAirborne.MoveRight
// (Native, Public)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::MoveRight(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.MoveRight");

	ASTExtraAirborne_MoveRight_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.MoveForward
// (Native, Public)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::MoveForward(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.MoveForward");

	ASTExtraAirborne_MoveForward_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.IsAutonomousFromBP
// (Final, Native, Private)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraAirborne::IsAutonomousFromBP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.IsAutonomousFromBP");

	ASTExtraAirborne_IsAutonomousFromBP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraAirborne.GetVerticalSpeed2
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraAirborne::GetVerticalSpeed2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.GetVerticalSpeed2");

	ASTExtraAirborne_GetVerticalSpeed2_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraAirborne.GetAirborneVelocity2
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraAirborne::GetAirborneVelocity2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.GetAirborneVelocity2");

	ASTExtraAirborne_GetAirborneVelocity2_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraAirborne.DoMoveRight
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::DoMoveRight(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.DoMoveRight");

	ASTExtraAirborne_DoMoveRight_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.DoMoveForward
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraAirborne::DoMoveForward(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.DoMoveForward");

	ASTExtraAirborne_DoMoveForward_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAirborne.ChangeCurForwardSpeedVFromBP
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 Speed                          (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraAirborne::ChangeCurForwardSpeedVFromBP(const struct FVector& Speed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAirborne.ChangeCurForwardSpeedVFromBP");

	ASTExtraAirborne_ChangeCurForwardSpeedVFromBP_Params params;
	params.Speed = Speed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraWeapon.WeaponNotifyChangeStateDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::WeaponNotifyChangeStateDelegate__DelegateSignature(TEnumAsByte<EFreshWeaponStateType> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraWeapon.WeaponNotifyChangeStateDelegate__DelegateSignature");

	ASTExtraWeapon_WeaponNotifyChangeStateDelegate__DelegateSignature_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraWeapon.WeaponEffectActionDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<EWeaponAction>     Action                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::WeaponEffectActionDelegate__DelegateSignature(TEnumAsByte<EWeaponAction> Action)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraWeapon.WeaponEffectActionDelegate__DelegateSignature");

	ASTExtraWeapon_WeaponEffectActionDelegate__DelegateSignature_Params params;
	params.Action = Action;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.RPC_ClientSyncPostFireHandledTime
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          InPostFireHandledTime          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::RPC_ClientSyncPostFireHandledTime(float InPostFireHandledTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.RPC_ClientSyncPostFireHandledTime");

	ASTExtraWeapon_RPC_ClientSyncPostFireHandledTime_Params params;
	params.InPostFireHandledTime = InPostFireHandledTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.RPC_ClientChangeFreshWeaponState
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::RPC_ClientChangeFreshWeaponState(TEnumAsByte<EFreshWeaponStateType> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.RPC_ClientChangeFreshWeaponState");

	ASTExtraWeapon_RPC_ClientChangeFreshWeaponState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.PlayLocalShellDropFX
// (Event, Public, BlueprintEvent)

void ASTExtraWeapon::PlayLocalShellDropFX()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.PlayLocalShellDropFX");

	ASTExtraWeapon_PlayLocalShellDropFX_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraWeapon.OnShootWeaponChangeStateDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::OnShootWeaponChangeStateDelegate__DelegateSignature(TEnumAsByte<EFreshWeaponStateType> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraWeapon.OnShootWeaponChangeStateDelegate__DelegateSignature");

	ASTExtraWeapon_OnShootWeaponChangeStateDelegate__DelegateSignature_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnRep_WeaponReconnectReplicateData
// (Final, Native, Protected)

void ASTExtraWeapon::OnRep_WeaponReconnectReplicateData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnRep_WeaponReconnectReplicateData");

	ASTExtraWeapon_OnRep_WeaponReconnectReplicateData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnRep_SimulatedOwnerPawn
// (Final, Native, Protected)

void ASTExtraWeapon::OnRep_SimulatedOwnerPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnRep_SimulatedOwnerPawn");

	ASTExtraWeapon_OnRep_SimulatedOwnerPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnRep_OwnerClientCreateWeaponData
// (Final, Native, Protected)

void ASTExtraWeapon::OnRep_OwnerClientCreateWeaponData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnRep_OwnerClientCreateWeaponData");

	ASTExtraWeapon_OnRep_OwnerClientCreateWeaponData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnRep_AvatarMeshChanged
// (Final, Native, Public)

void ASTExtraWeapon::OnRep_AvatarMeshChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnRep_AvatarMeshChanged");

	ASTExtraWeapon_OnRep_AvatarMeshChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnRep_AttachmentReplication
// (Native, Public)

void ASTExtraWeapon::OnRep_AttachmentReplication()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnRep_AttachmentReplication");

	ASTExtraWeapon_OnRep_AttachmentReplication_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnReleaseTrigger
// (Native, Public, BlueprintCallable)

void ASTExtraWeapon::OnReleaseTrigger()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnReleaseTrigger");

	ASTExtraWeapon_OnReleaseTrigger_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.OnPushTrigger
// (Native, Public, BlueprintCallable)

void ASTExtraWeapon::OnPushTrigger()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.OnPushTrigger");

	ASTExtraWeapon_OnPushTrigger_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWeapon.JudgeHasEquipedComponentSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<EWeaponComponentType> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraWeapon::JudgeHasEquipedComponentSlot(TEnumAsByte<EWeaponComponentType> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.JudgeHasEquipedComponentSlot");

	ASTExtraWeapon_JudgeHasEquipedComponentSlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.HasComponentSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<EWeaponComponentType> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraWeapon::HasComponentSlot(TEnumAsByte<EWeaponComponentType> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.HasComponentSlot");

	ASTExtraWeapon_HasComponentSlot_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponStaticMeshComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UStaticMeshComponent*    ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UStaticMeshComponent* ASTExtraWeapon::GetWeaponStaticMeshComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponStaticMeshComponent");

	ASTExtraWeapon_GetWeaponStaticMeshComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponSkeletalMeshComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*  ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USkeletalMeshComponent* ASTExtraWeapon::GetWeaponSkeletalMeshComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponSkeletalMeshComponent");

	ASTExtraWeapon_GetWeaponSkeletalMeshComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraWeapon::GetWeaponName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponName");

	ASTExtraWeapon_GetWeaponName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponMeshComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* ASTExtraWeapon::GetWeaponMeshComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponMeshComponent");

	ASTExtraWeapon_GetWeaponMeshComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponEntityComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWeaponEntity*           ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UWeaponEntity* ASTExtraWeapon::GetWeaponEntityComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponEntityComponent");

	ASTExtraWeapon_GetWeaponEntityComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetWeaponAttachSocket
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraWeapon::GetWeaponAttachSocket()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetWeaponAttachSocket");

	ASTExtraWeapon_GetWeaponAttachSocket_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetSpecificHandler
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWeaponSpecificHandler*  ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UWeaponSpecificHandler* ASTExtraWeapon::GetSpecificHandler()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetSpecificHandler");

	ASTExtraWeapon_GetSpecificHandler_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPlayerName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraWeapon::GetOwnerPlayerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPlayerName");

	ASTExtraWeapon_GetOwnerPlayerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPlayerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APlayerController*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APlayerController* ASTExtraWeapon::GetOwnerPlayerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPlayerController");

	ASTExtraWeapon_GetOwnerPlayerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APawn* ASTExtraWeapon::GetOwnerPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerPawn");

	ASTExtraWeapon_GetOwnerPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerName
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraWeapon::GetOwnerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerName");

	ASTExtraWeapon_GetOwnerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* ASTExtraWeapon::GetOwnerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerController");

	ASTExtraWeapon_GetOwnerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetOwnerActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* ASTExtraWeapon::GetOwnerActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetOwnerActor");

	ASTExtraWeapon_GetOwnerActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetItemDefineID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID ASTExtraWeapon::GetItemDefineID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetItemDefineID");

	ASTExtraWeapon_GetItemDefineID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetComponentSlotTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<EWeaponComponentType> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FWeaponComponentItemData ReturnValue                    (Parm, OutParm, ReturnParm)

struct FWeaponComponentItemData ASTExtraWeapon::GetComponentSlotTarget(TEnumAsByte<EWeaponComponentType> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetComponentSlotTarget");

	ASTExtraWeapon_GetComponentSlotTarget_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetColorByTeamID
// (Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// int                            TeamID                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FLinearColor ASTExtraWeapon::GetColorByTeamID(int TeamID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetColorByTeamID");

	ASTExtraWeapon_GetColorByTeamID_Params params;
	params.TeamID = TeamID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.GetBackpackItemHandle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UItemHandleBase*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UItemHandleBase* ASTExtraWeapon::GetBackpackItemHandle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.GetBackpackItemHandle");

	ASTExtraWeapon_GetBackpackItemHandle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWeapon.ChangeSequenceState
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> StateType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWeapon::ChangeSequenceState(TEnumAsByte<EFreshWeaponStateType> StateType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWeapon.ChangeSequenceState");

	ASTExtraWeapon_ChangeSequenceState_Params params;
	params.StateType = StateType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StopFireFilter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::StopFireFilter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StopFireFilter");

	ASTExtraShootWeapon_StopFireFilter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StopFire
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> ToState                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::StopFire(TEnumAsByte<EFreshWeaponStateType> ToState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StopFire");

	ASTExtraShootWeapon_StopFire_Params params;
	params.ToState = ToState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StartReload
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraShootWeapon::StartReload()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StartReload");

	ASTExtraShootWeapon_StartReload_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StartFireFilter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::StartFireFilter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StartFireFilter");

	ASTExtraShootWeapon_StartFireFilter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StartFire
// (Native, Public, BlueprintCallable)

void ASTExtraShootWeapon::StartFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StartFire");

	ASTExtraShootWeapon_StartFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StartDoPreBarrel
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          HandledTime                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::StartDoPreBarrel(float HandledTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StartDoPreBarrel");

	ASTExtraShootWeapon_StartDoPreBarrel_Params params;
	params.HandledTime = HandledTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.StartDoBarrel
// (Native, Public, BlueprintCallable)

void ASTExtraShootWeapon::StartDoBarrel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.StartDoBarrel");

	ASTExtraShootWeapon_StartDoBarrel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.ShowDefaultScope
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bShow                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::ShowDefaultScope(bool bShow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.ShowDefaultScope");

	ASTExtraShootWeapon_ShowDefaultScope_Params params;
	params.bShow = bShow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.ShowDefaultAttachmentComponentByType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWeaponAttachmentSocketType    Type                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bVisible                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::ShowDefaultAttachmentComponentByType(EWeaponAttachmentSocketType Type, bool bVisible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.ShowDefaultAttachmentComponentByType");

	ASTExtraShootWeapon_ShowDefaultAttachmentComponentByType_Params params;
	params.Type = Type;
	params.bVisible = bVisible;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetWeaponAttrModifierEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AttrModifierID                 (Parm, ZeroConstructor)
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::SetWeaponAttrModifierEnable(const struct FString& AttrModifierID, bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetWeaponAttrModifierEnable");

	ASTExtraShootWeapon_SetWeaponAttrModifierEnable_Params params;
	params.AttrModifierID = AttrModifierID;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetCurShootType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> shootType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::SetCurShootType(TEnumAsByte<ESTEWeaponShootType> shootType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetCurShootType");

	ASTExtraShootWeapon_SetCurShootType_Params params;
	params.shootType = shootType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetCurrentBulletNumInClipOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::SetCurrentBulletNumInClipOnServer(int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetCurrentBulletNumInClipOnServer");

	ASTExtraShootWeapon_SetCurrentBulletNumInClipOnServer_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetCurrentBulletNumInClipOnClient
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::SetCurrentBulletNumInClipOnClient(int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetCurrentBulletNumInClipOnClient");

	ASTExtraShootWeapon_SetCurrentBulletNumInClipOnClient_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetCurReloadMethod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EWeaponReloadMethod> method                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::SetCurReloadMethod(TEnumAsByte<EWeaponReloadMethod> method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetCurReloadMethod");

	ASTExtraShootWeapon_SetCurReloadMethod_Params params;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.SetAvailableWeaponAttachmentSocketTypeList
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<EWeaponAttachmentSocketType> List                           (Parm, OutParm, ZeroConstructor)

void ASTExtraShootWeapon::SetAvailableWeaponAttachmentSocketTypeList(TArray<EWeaponAttachmentSocketType>* List)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.SetAvailableWeaponAttachmentSocketTypeList");

	ASTExtraShootWeapon_SetAvailableWeaponAttachmentSocketTypeList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (List != nullptr)
		*List = params.List;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.RPC_ClientSetCurShootType
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> shootType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::RPC_ClientSetCurShootType(TEnumAsByte<ESTEWeaponShootType> shootType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.RPC_ClientSetCurShootType");

	ASTExtraShootWeapon_RPC_ClientSetCurShootType_Params params;
	params.shootType = shootType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.RPC_ClientSetCurReloadMethod
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// TEnumAsByte<EWeaponReloadMethod> method                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::RPC_ClientSetCurReloadMethod(TEnumAsByte<EWeaponReloadMethod> method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.RPC_ClientSetCurReloadMethod");

	ASTExtraShootWeapon_RPC_ClientSetCurReloadMethod_Params params;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.RPC_Client_SetBulletNumInClip
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::RPC_Client_SetBulletNumInClip(int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.RPC_Client_SetBulletNumInClip");

	ASTExtraShootWeapon_RPC_Client_SetBulletNumInClip_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.ResetInitialBulletNumInClip
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bSetZero                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::ResetInitialBulletNumInClip(bool bSetZero)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.ResetInitialBulletNumInClip");

	ASTExtraShootWeapon_ResetInitialBulletNumInClip_Params params;
	params.bSetZero = bSetZero;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponUnEquipDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnWeaponUnEquipDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponUnEquipDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponUnEquipDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponShootHitDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasOutParms)
// Parameters:
// struct FShootWeaponDamageEvent DamageDetail                   (ConstParm, Parm, OutParm, ReferenceParm)
// struct FBulletHitInfoUploadData HitData                        (ConstParm, Parm, OutParm, ReferenceParm)
// struct FLocalShootHitData      LocalHitData                   (ConstParm, Parm, OutParm, ReferenceParm)

void ASTExtraShootWeapon::OnWeaponShootHitDelegate__DelegateSignature(const struct FShootWeaponDamageEvent& DamageDetail, const struct FBulletHitInfoUploadData& HitData, const struct FLocalShootHitData& LocalHitData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponShootHitDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponShootHitDelegate__DelegateSignature_Params params;
	params.DamageDetail = DamageDetail;
	params.HitData = HitData;
	params.LocalHitData = LocalHitData;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponShootDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnWeaponShootDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponShootDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponShootDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponSecurityLogShootActorDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate, HasOutParms)
// Parameters:
// class AActor*                  InHitActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSecurityLogHitTargetInfo TargetInfo                     (ConstParm, Parm, OutParm, ReferenceParm)

void ASTExtraShootWeapon::OnWeaponSecurityLogShootActorDelegate__DelegateSignature(class AActor* InHitActor, const struct FSecurityLogHitTargetInfo& TargetInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponSecurityLogShootActorDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponSecurityLogShootActorDelegate__DelegateSignature_Params params;
	params.InHitActor = InHitActor;
	params.TargetInfo = TargetInfo;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponReloadStartDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnWeaponReloadStartDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponReloadStartDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponReloadStartDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponReloadEndDelegage__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnWeaponReloadEndDelegage__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponReloadEndDelegage__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponReloadEndDelegage__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponEquipDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnWeaponEquipDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnWeaponEquipDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnWeaponEquipDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnStopFireDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnStopFireDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnStopFireDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnStopFireDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnStartFireDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnStartFireDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnStartFireDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnStartFireDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnShootWeaponAutoReloadDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnShootWeaponAutoReloadDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnShootWeaponAutoReloadDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnShootWeaponAutoReloadDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_HitDataArray
// (Final, Native, Public)

void ASTExtraShootWeapon::OnRep_HitDataArray()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_HitDataArray");

	ASTExtraShootWeapon_OnRep_HitDataArray_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_CurMaxBulletNumChange
// (Final, Native, Public)

void ASTExtraShootWeapon::OnRep_CurMaxBulletNumChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_CurMaxBulletNumChange");

	ASTExtraShootWeapon_OnRep_CurMaxBulletNumChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_CurBulletNumInClipOnSimulatedClients
// (Final, Native, Protected)

void ASTExtraShootWeapon::OnRep_CurBulletNumInClipOnSimulatedClients()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.OnRep_CurBulletNumInClipOnSimulatedClients");

	ASTExtraShootWeapon_OnRep_CurBulletNumInClipOnSimulatedClients_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnMaxBulletChange__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnMaxBulletChange__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnMaxBulletChange__DelegateSignature");

	ASTExtraShootWeapon_OnMaxBulletChange__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnCurBulletChange__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnCurBulletChange__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnCurBulletChange__DelegateSignature");

	ASTExtraShootWeapon_OnCurBulletChange__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnBulletNumChangeDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeapon::OnBulletNumChangeDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeapon.OnBulletNumChangeDelegate__DelegateSignature");

	ASTExtraShootWeapon_OnBulletNumChangeDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.NotifyServerNoneShootAction
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraShootWeapon::NotifyServerNoneShootAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.NotifyServerNoneShootAction");

	ASTExtraShootWeapon_NotifyServerNoneShootAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.NotifyClientNoneShootAction
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)

void ASTExtraShootWeapon::NotifyClientNoneShootAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.NotifyClientNoneShootAction");

	ASTExtraShootWeapon_NotifyClientNoneShootAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.LocalSetBulletNumInClip
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::LocalSetBulletNumInClip(int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.LocalSetBulletNumInClip");

	ASTExtraShootWeapon_LocalSetBulletNumInClip_Params params;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.IsInPreFire
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::IsInPreFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.IsInPreFire");

	ASTExtraShootWeapon_IsInPreFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.HandleWeaponScopeEquiped
// (Final, Native, Public)

void ASTExtraShootWeapon::HandleWeaponScopeEquiped()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.HandleWeaponScopeEquiped");

	ASTExtraShootWeapon_HandleWeaponScopeEquiped_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponReloadType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EWeaponReloadType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EWeaponReloadType> ASTExtraShootWeapon::GetWeaponReloadType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponReloadType");

	ASTExtraShootWeapon_GetWeaponReloadType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponID
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraShootWeapon::GetWeaponID()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponID");

	ASTExtraShootWeapon_GetWeaponID_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponBodyLength
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetWeaponBodyLength()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetWeaponBodyLength");

	ASTExtraShootWeapon_GetWeaponBodyLength_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetTraceDistanceFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetTraceDistanceFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetTraceDistanceFromEntity");

	ASTExtraShootWeapon_GetTraceDistanceFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetSilencerSocketNameFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraShootWeapon::GetSilencerSocketNameFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetSilencerSocketNameFromEntity");

	ASTExtraShootWeapon_GetSilencerSocketNameFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetShootWeaponEntityComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UShootWeaponEntity*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UShootWeaponEntity* ASTExtraShootWeapon::GetShootWeaponEntityComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetShootWeaponEntityComponent");

	ASTExtraShootWeapon_GetShootWeaponEntityComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetShootWeaponEffectComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UShootWeaponEffectComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UShootWeaponEffectComponent* ASTExtraShootWeapon::GetShootWeaponEffectComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetShootWeaponEffectComponent");

	ASTExtraShootWeapon_GetShootWeaponEffectComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetShootTypeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESTEWeaponShootType> ASTExtraShootWeapon::GetShootTypeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetShootTypeFromEntity");

	ASTExtraShootWeapon_GetShootTypeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetShootIntervalFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetShootIntervalFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetShootIntervalFromEntity");

	ASTExtraShootWeapon_GetShootIntervalFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetShellDropSocketNameFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraShootWeapon::GetShellDropSocketNameFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetShellDropSocketNameFromEntity");

	ASTExtraShootWeapon_GetShellDropSocketNameFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeID
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           bIsAngledOpticalSight          (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraShootWeapon::GetScopeID(bool bIsAngledOpticalSight)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeID");

	ASTExtraShootWeapon_GetScopeID_Params params;
	params.bIsAngledOpticalSight = bIsAngledOpticalSight;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeAimCameraTransform
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   SocketName                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            SocketIndex                    (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* ASTExtraShootWeapon::GetScopeAimCameraTransform(const struct FName& SocketName, int SocketIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeAimCameraTransform");

	ASTExtraShootWeapon_GetScopeAimCameraTransform_Params params;
	params.SocketName = SocketName;
	params.SocketIndex = SocketIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeAimCameraSecondScope2
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   SocketName                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            SocketIndex                    (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* ASTExtraShootWeapon::GetScopeAimCameraSecondScope2(const struct FName& SocketName, int SocketIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetScopeAimCameraSecondScope2");

	ASTExtraShootWeapon_GetScopeAimCameraSecondScope2_Params params;
	params.SocketName = SocketName;
	params.SocketIndex = SocketIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTimeMagOutFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReloadTimeMagOutFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTimeMagOutFromEntity");

	ASTExtraShootWeapon_GetReloadTimeMagOutFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReloadTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTimeFromEntity");

	ASTExtraShootWeapon_GetReloadTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTIDName
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EWeaponReloadMethod> method                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraShootWeapon::GetReloadTIDName(TEnumAsByte<EWeaponReloadMethod> method)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTIDName");

	ASTExtraShootWeapon_GetReloadTIDName_Params params;
	params.method = method;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTacticalTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReloadTacticalTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadTacticalTimeFromEntity");

	ASTExtraShootWeapon_GetReloadTacticalTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadDurationStartFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReloadDurationStartFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadDurationStartFromEntity");

	ASTExtraShootWeapon_GetReloadDurationStartFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadDurationLoopFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReloadDurationLoopFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReloadDurationLoopFromEntity");

	ASTExtraShootWeapon_GetReloadDurationLoopFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetRelativeMuzzleTransform
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FTransform              ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FTransform ASTExtraShootWeapon::GetRelativeMuzzleTransform()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetRelativeMuzzleTransform");

	ASTExtraShootWeapon_GetRelativeMuzzleTransform_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetReferenceDistance
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetReferenceDistance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetReferenceDistance");

	ASTExtraShootWeapon_GetReferenceDistance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetRangeModifier
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetRangeModifier()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetRangeModifier");

	ASTExtraShootWeapon_GetRangeModifier_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetRangeAttenuateFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FSRangeAttenuateConfig> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FSRangeAttenuateConfig> ASTExtraShootWeapon::GetRangeAttenuateFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetRangeAttenuateFromEntity");

	ASTExtraShootWeapon_GetRangeAttenuateFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetPreFireTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetPreFireTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetPreFireTimeFromEntity");

	ASTExtraShootWeapon_GetPreFireTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetPostReloadTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetPostReloadTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetPostReloadTimeFromEntity");

	ASTExtraShootWeapon_GetPostReloadTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetPostFireTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetPostFireTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetPostFireTimeFromEntity");

	ASTExtraShootWeapon_GetPostFireTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetMuzzleTransform
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FTransform              ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FTransform ASTExtraShootWeapon::GetMuzzleTransform()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetMuzzleTransform");

	ASTExtraShootWeapon_GetMuzzleTransform_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetMuzzleSocketNameFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraShootWeapon::GetMuzzleSocketNameFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetMuzzleSocketNameFromEntity");

	ASTExtraShootWeapon_GetMuzzleSocketNameFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxValidHitTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetMaxValidHitTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxValidHitTimeFromEntity");

	ASTExtraShootWeapon_GetMaxValidHitTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxImpactEffectSkipTimeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetMaxImpactEffectSkipTimeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxImpactEffectSkipTimeFromEntity");

	ASTExtraShootWeapon_GetMaxImpactEffectSkipTimeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxBulletNumInOneClipFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraShootWeapon::GetMaxBulletNumInOneClipFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetMaxBulletNumInOneClipFromEntity");

	ASTExtraShootWeapon_GetMaxBulletNumInOneClipFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetImpactEffectSkipDistanceFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetImpactEffectSkipDistanceFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetImpactEffectSkipDistanceFromEntity");

	ASTExtraShootWeapon_GetImpactEffectSkipDistanceFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetHitPartCoff
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FWeaponHitPartCoff      ReturnValue                    (Parm, OutParm, ReturnParm)

struct FWeaponHitPartCoff ASTExtraShootWeapon::GetHitPartCoff()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetHitPartCoff");

	ASTExtraShootWeapon_GetHitPartCoff_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetGameDeviationFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetGameDeviationFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetGameDeviationFactor");

	ASTExtraShootWeapon_GetGameDeviationFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetFiringSuppressorSocketNameFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName ASTExtraShootWeapon::GetFiringSuppressorSocketNameFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetFiringSuppressorSocketNameFromEntity");

	ASTExtraShootWeapon_GetFiringSuppressorSocketNameFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetFireSensitiveYawRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetFireSensitiveYawRate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetFireSensitiveYawRate");

	ASTExtraShootWeapon_GetFireSensitiveYawRate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetFireSensitivePitchRate
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetFireSensitivePitchRate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetFireSensitivePitchRate");

	ASTExtraShootWeapon_GetFireSensitivePitchRate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetDefaultAttachmentComponentByType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWeaponAttachmentSocketType    Type                           (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* ASTExtraShootWeapon::GetDefaultAttachmentComponentByType(EWeaponAttachmentSocketType Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetDefaultAttachmentComponentByType");

	ASTExtraShootWeapon_GetDefaultAttachmentComponentByType_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCurSightType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESightType>        ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESightType> ASTExtraShootWeapon::GetCurSightType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCurSightType");

	ASTExtraShootWeapon_GetCurSightType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCurReloadTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetCurReloadTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCurReloadTime");

	ASTExtraShootWeapon_GetCurReloadTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCurReloadMethod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EWeaponReloadMethod> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EWeaponReloadMethod> ASTExtraShootWeapon::GetCurReloadMethod()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCurReloadMethod");

	ASTExtraShootWeapon_GetCurReloadMethod_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairInitSize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetCrossHairInitSize()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairInitSize");

	ASTExtraShootWeapon_GetCrossHairInitSize_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairBurstSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetCrossHairBurstSpeed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairBurstSpeed");

	ASTExtraShootWeapon_GetCrossHairBurstSpeed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairBurstIncreaseSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetCrossHairBurstIncreaseSpeed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetCrossHairBurstIncreaseSpeed");

	ASTExtraShootWeapon_GetCrossHairBurstIncreaseSpeed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetClipHasInfiniteBulletsFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::GetClipHasInfiniteBulletsFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetClipHasInfiniteBulletsFromEntity");

	ASTExtraShootWeapon_GetClipHasInfiniteBulletsFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetChildMeshComp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   compTag                        (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* ASTExtraShootWeapon::GetChildMeshComp(const struct FName& compTag)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetChildMeshComp");

	ASTExtraShootWeapon_GetChildMeshComp_Params params;
	params.compTag = compTag;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBurstShootIntervalFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetBurstShootIntervalFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBurstShootIntervalFromEntity");

	ASTExtraShootWeapon_GetBurstShootIntervalFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBurstShootBulletsNumFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraShootWeapon::GetBurstShootBulletsNumFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBurstShootBulletsNumFromEntity");

	ASTExtraShootWeapon_GetBurstShootBulletsNumFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletTypeFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FItemDefineID           ReturnValue                    (Parm, OutParm, ReturnParm)

struct FItemDefineID ASTExtraShootWeapon::GetBulletTypeFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletTypeFromEntity");

	ASTExtraShootWeapon_GetBulletTypeFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletRangeEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetBulletRangeEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletRangeEntity");

	ASTExtraShootWeapon_GetBulletRangeEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletNumSingleShotFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetBulletNumSingleShotFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletNumSingleShotFromEntity");

	ASTExtraShootWeapon_GetBulletNumSingleShotFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletFireSpeedFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetBulletFireSpeedFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBulletFireSpeedFromEntity");

	ASTExtraShootWeapon_GetBulletFireSpeedFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetBaseImpactDamageEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetBaseImpactDamageEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetBaseImpactDamageEntity");

	ASTExtraShootWeapon_GetBaseImpactDamageEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAvailableWeaponAttachmentSocketTypeList
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<EWeaponAttachmentSocketType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<EWeaponAttachmentSocketType> ASTExtraShootWeapon::GetAvailableWeaponAttachmentSocketTypeList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAvailableWeaponAttachmentSocketTypeList");

	ASTExtraShootWeapon_GetAvailableWeaponAttachmentSocketTypeList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAutoReloadFromEntity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::GetAutoReloadFromEntity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAutoReloadFromEntity");

	ASTExtraShootWeapon_GetAutoReloadFromEntity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetADSManualStop
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraShootWeapon::GetADSManualStop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetADSManualStop");

	ASTExtraShootWeapon_GetADSManualStop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesVRecoilFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetAccessoriesVRecoilFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesVRecoilFactor");

	ASTExtraShootWeapon_GetAccessoriesVRecoilFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesRecoveryFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetAccessoriesRecoveryFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesRecoveryFactor");

	ASTExtraShootWeapon_GetAccessoriesRecoveryFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesHRecoilFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetAccessoriesHRecoilFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesHRecoilFactor");

	ASTExtraShootWeapon_GetAccessoriesHRecoilFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesDeviationFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraShootWeapon::GetAccessoriesDeviationFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.GetAccessoriesDeviationFactor");

	ASTExtraShootWeapon_GetAccessoriesDeviationFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.FixBulletNumWithValideData
// (Final, Native, Public, BlueprintCallable)

void ASTExtraShootWeapon::FixBulletNumWithValideData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.FixBulletNumWithValideData");

	ASTExtraShootWeapon_FixBulletNumWithValideData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.EnableInfiniteBullets
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraShootWeapon::EnableInfiniteBullets(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.EnableInfiniteBullets");

	ASTExtraShootWeapon_EnableInfiniteBullets_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeapon.ClearWeaponAttrModifier
// (Final, Native, Public, BlueprintCallable)

void ASTExtraShootWeapon::ClearWeaponAttrModifier()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeapon.ClearWeaponAttrModifier");

	ASTExtraShootWeapon_ClearWeaponAttrModifier_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandlePlayerAnimMontagePlayDelegate
// (Native, Public)
// Parameters:
// class UAnimMontage*            MontageToPlay                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bWantsPlay                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          PlayRate                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   StartSection                   (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstanceBase::HandlePlayerAnimMontagePlayDelegate(class UAnimMontage* MontageToPlay, bool bWantsPlay, float PlayRate, const struct FName& StartSection)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandlePlayerAnimMontagePlayDelegate");

	USTExtraAnimInstanceBase_HandlePlayerAnimMontagePlayDelegate_Params params;
	params.MontageToPlay = MontageToPlay;
	params.bWantsPlay = bWantsPlay;
	params.PlayRate = PlayRate;
	params.StartSection = StartSection;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandleOwnerAnimEvent
// (Native, Public)
// Parameters:
// struct FName                   EventMsg                       (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstanceBase::HandleOwnerAnimEvent(const struct FName& EventMsg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandleOwnerAnimEvent");

	USTExtraAnimInstanceBase_HandleOwnerAnimEvent_Params params;
	params.EventMsg = EventMsg;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandleAnimPlaySlotAnimDelegate
// (Native, Public)
// Parameters:
// class UAnimSequenceBase*       AnimSequence                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bWantsPlay                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   SlotName                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          PlayRate                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          blendTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstanceBase::HandleAnimPlaySlotAnimDelegate(class UAnimSequenceBase* AnimSequence, bool bWantsPlay, const struct FName& SlotName, float PlayRate, float blendTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstanceBase.HandleAnimPlaySlotAnimDelegate");

	USTExtraAnimInstanceBase_HandleAnimPlaySlotAnimDelegate_Params params;
	params.AnimSequence = AnimSequence;
	params.bWantsPlay = bWantsPlay;
	params.SlotName = SlotName;
	params.PlayRate = PlayRate;
	params.blendTime = blendTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.TryToFireFlareGun
// (Final, Native, Public, BlueprintCallable)

void USTExtraAnimInstance::TryToFireFlareGun()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.TryToFireFlareGun");

	USTExtraAnimInstance_TryToFireFlareGun_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.SetVelocityZFactor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          NewFactor                      (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstance::SetVelocityZFactor(float NewFactor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.SetVelocityZFactor");

	USTExtraAnimInstance_SetVelocityZFactor_Params params;
	params.NewFactor = NewFactor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.SetC_ViewRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                NewRotator                     (Parm, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstance::SetC_ViewRotation(const struct FRotator& NewRotator, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.SetC_ViewRotation");

	USTExtraAnimInstance_SetC_ViewRotation_Params params;
	params.NewRotator = NewRotator;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.SetC_PoseType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ECharacterPoseType> NewECharacterPoseType          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstance::SetC_PoseType(TEnumAsByte<ECharacterPoseType> NewECharacterPoseType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.SetC_PoseType");

	USTExtraAnimInstance_SetC_PoseType_Params params;
	params.NewECharacterPoseType = NewECharacterPoseType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.DumpAllProperties
// (Final, Native, Protected, BlueprintCallable, Const)

void USTExtraAnimInstance::DumpAllProperties()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.DumpAllProperties");

	USTExtraAnimInstance_DumpAllProperties_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.DumpAllAnimInstancesInThisWorld
// (Final, Exec, Native, Protected, Const)

void USTExtraAnimInstance::DumpAllAnimInstancesInThisWorld()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.DumpAllAnimInstancesInThisWorld");

	USTExtraAnimInstance_DumpAllAnimInstancesInThisWorld_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.CacheParamList
// (Native, Public)
// Parameters:
// float                          DeltaSeconds                   (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraAnimInstance::CacheParamList(float DeltaSeconds)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.CacheParamList");

	USTExtraAnimInstance_CacheParamList_Params params;
	params.DeltaSeconds = DeltaSeconds;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance.CacheAnimVarList
// (Final, Native, Public)

void USTExtraAnimInstance::CacheAnimVarList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance.CacheAnimVarList");

	USTExtraAnimInstance_CacheAnimVarList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraAnimInstance_YearBeast.CacheAnimVarList
// (Final, Native, Public)

void USTExtraAnimInstance_YearBeast::CacheAnimVarList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraAnimInstance_YearBeast.CacheAnimVarList");

	USTExtraAnimInstance_YearBeast_CacheAnimVarList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.TriggerEntryEvent_Implementation
// (Native, Public, BlueprintCallable)
// Parameters:
// EUTSkillEntry                  EntryEvent                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraCharacter::TriggerEntryEvent_Implementation(EUTSkillEntry EntryEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.TriggerEntryEvent_Implementation");

	ASTExtraCharacter_TriggerEntryEvent_Implementation_Params params;
	params.EntryEvent = EntryEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.TriggerCustomEvent_Implementation
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EUAESkillEvent>    EventType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraCharacter::TriggerCustomEvent_Implementation(TEnumAsByte<EUAESkillEvent> EventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.TriggerCustomEvent_Implementation");

	ASTExtraCharacter_TriggerCustomEvent_Implementation_Params params;
	params.EventType = EventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.SetBuffExpiry
// (Native, Public)
// Parameters:
// struct FName                   BuffName                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          ExpirySecondsFromNow           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraCharacter::SetBuffExpiry(const struct FName& BuffName, float ExpirySecondsFromNow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.SetBuffExpiry");

	ASTExtraCharacter_SetBuffExpiry_Params params;
	params.BuffName = BuffName;
	params.ExpirySecondsFromNow = ExpirySecondsFromNow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.RemoveBuff
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   BuffName                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           RemoveLayerOnly                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  BuffApplierActor               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraCharacter::RemoveBuff(const struct FName& BuffName, bool RemoveLayerOnly, class AActor* BuffApplierActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.RemoveBuff");

	ASTExtraCharacter_RemoveBuff_Params params;
	params.BuffName = BuffName;
	params.RemoveLayerOnly = RemoveLayerOnly;
	params.BuffApplierActor = BuffApplierActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.OnRep_Temperature
// (Native, Protected)

void ASTExtraCharacter::OnRep_Temperature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.OnRep_Temperature");

	ASTExtraCharacter_OnRep_Temperature_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.OnRep_Health
// (Native, Protected)

void ASTExtraCharacter::OnRep_Health()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.OnRep_Health");

	ASTExtraCharacter_OnRep_Health_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.IsAlive
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraCharacter::IsAlive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.IsAlive");

	ASTExtraCharacter_IsAlive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.HasBuff
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   BuffName                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraCharacter::HasBuff(const struct FName& BuffName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.HasBuff");

	ASTExtraCharacter_HasBuff_Params params;
	params.BuffName = BuffName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.GetPlayerNameSafety
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraCharacter::GetPlayerNameSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.GetPlayerNameSafety");

	ASTExtraCharacter_GetPlayerNameSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.GetInitialCustomPlayerName
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraCharacter::GetInitialCustomPlayerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.GetInitialCustomPlayerName");

	ASTExtraCharacter_GetInitialCustomPlayerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.GetCurSkill
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AUTSkill*                ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AUTSkill* ASTExtraCharacter::GetCurSkill()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.GetCurSkill");

	ASTExtraCharacter_GetCurSkill_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.ExtractDamageParams
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// class AActor*                  DamagetCauser                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageType                     (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraCharacter::ExtractDamageParams(const struct FDamageEvent& DamageEvent, class AActor* DamagetCauser, int* DamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.ExtractDamageParams");

	ASTExtraCharacter_ExtractDamageParams_Params params;
	params.DamageEvent = DamageEvent;
	params.DamagetCauser = DamagetCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DamageType != nullptr)
		*DamageType = params.DamageType;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraCharacter.DelayHidden
// (Final, Native, Protected)

void ASTExtraCharacter::DelayHidden()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.DelayHidden");

	ASTExtraCharacter_DelayHidden_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.BPReceiveDamage
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraCharacter::BPReceiveDamage(float Damage, class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.BPReceiveDamage");

	ASTExtraCharacter_BPReceiveDamage_Params params;
	params.Damage = Damage;
	params.DamageType = DamageType;
	params.InstigatedBy = InstigatedBy;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraCharacter.AddBuff
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   BuffName                       (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             BuffCauser                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            LayerCount                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  BuffApplierActor               (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraCharacter::AddBuff(const struct FName& BuffName, class AController* BuffCauser, int LayerCount, class AActor* BuffApplierActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraCharacter.AddBuff");

	ASTExtraCharacter_AddBuff_Params params;
	params.BuffName = BuffName;
	params.BuffCauser = BuffCauser;
	params.LayerCount = LayerCount;
	params.BuffApplierActor = BuffApplierActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.VaultStartPosNotifyBPToCpp
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// bool                           isvaultting                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsValidVault                   (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   vaultCharacter                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 startPos                       (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::VaultStartPosNotifyBPToCpp(bool isvaultting, bool IsValidVault, class ASTExtraBaseCharacter* vaultCharacter, const struct FVector& startPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.VaultStartPosNotifyBPToCpp");

	ASTExtraBaseCharacter_VaultStartPosNotifyBPToCpp_Params params;
	params.isvaultting = isvaultting;
	params.IsValidVault = IsValidVault;
	params.vaultCharacter = vaultCharacter;
	params.startPos = startPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.VaultFailPawnCPP
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// struct FString                 content                        (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::VaultFailPawnCPP(const struct FString& content)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.VaultFailPawnCPP");

	ASTExtraBaseCharacter_VaultFailPawnCPP_Params params;
	params.content = content;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.VaultFailPawnBluePrint
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// struct FString                 content                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::VaultFailPawnBluePrint(const struct FString& content)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.VaultFailPawnBluePrint");

	ASTExtraBaseCharacter_VaultFailPawnBluePrint_Params params;
	params.content = content;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.UserCancelRescue
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::UserCancelRescue()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.UserCancelRescue");

	ASTExtraBaseCharacter_UserCancelRescue_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.UpdatePoseCollisionCpp
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEPoseState>     CurState                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     preState                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::UpdatePoseCollisionCpp(TEnumAsByte<ESTEPoseState> CurState, TEnumAsByte<ESTEPoseState> preState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.UpdatePoseCollisionCpp");

	ASTExtraBaseCharacter_UpdatePoseCollisionCpp_Params params;
	params.CurState = CurState;
	params.preState = preState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.UpdateAllInstanceBodyTransform
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Type                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::UpdateAllInstanceBodyTransform(int Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.UpdateAllInstanceBodyTransform");

	ASTExtraBaseCharacter_UpdateAllInstanceBodyTransform_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.UnequipWeaponFinish
// (Final, Native, Public)

void ASTExtraBaseCharacter::UnequipWeaponFinish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.UnequipWeaponFinish");

	ASTExtraBaseCharacter_UnequipWeaponFinish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.UnequipWeapon
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bSwitchWeapon                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::UnequipWeapon(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bSwitchWeapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.UnequipWeapon");

	ASTExtraBaseCharacter_UnequipWeapon_Params params;
	params.Slot = Slot;
	params.bSwitchWeapon = bSwitchWeapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.TryToBroadcastFatalDamageEvent
// (Final, Native, Public, HasOutParms)
// Parameters:
// class AController*             causer                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            HSChangeMargin                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           IsHeadshot                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::TryToBroadcastFatalDamageEvent(class AController* causer, int HSChangeMargin, const struct FDamageEvent& DamageEvent, bool IsHeadshot, class AActor* DamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.TryToBroadcastFatalDamageEvent");

	ASTExtraBaseCharacter_TryToBroadcastFatalDamageEvent_Params params;
	params.causer = causer;
	params.HSChangeMargin = HSChangeMargin;
	params.DamageEvent = DamageEvent;
	params.IsHeadshot = IsHeadshot;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.TryPeek
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsLeft                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ButtonDown                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::TryPeek(bool IsLeft, bool ButtonDown)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.TryPeek");

	ASTExtraBaseCharacter_TryPeek_Params params;
	params.IsLeft = IsLeft;
	params.ButtonDown = ButtonDown;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.TriggerEntryEvent_Implementation
// (Native, Public, BlueprintCallable)
// Parameters:
// EUTSkillEntry                  EntryEvent                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::TriggerEntryEvent_Implementation(EUTSkillEntry EntryEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.TriggerEntryEvent_Implementation");

	ASTExtraBaseCharacter_TriggerEntryEvent_Implementation_Params params;
	params.EntryEvent = EntryEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraBaseCharacter.TakeDamageWhenThrowedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraBaseCharacter::TakeDamageWhenThrowedDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraBaseCharacter.TakeDamageWhenThrowedDelegate__DelegateSignature");

	ASTExtraBaseCharacter_TakeDamageWhenThrowedDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SyncServerTagsChange
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FName>           newTags                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FName>           oldTags                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::SyncServerTagsChange(TArray<struct FName> newTags, TArray<struct FName> oldTags)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SyncServerTagsChange");

	ASTExtraBaseCharacter_SyncServerTagsChange_Params params;
	params.newTags = newTags;
	params.oldTags = oldTags;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SyncDeadTombBoxToController
// (Native, Protected)
// Parameters:
// class APlayerTombBox*          _DeadTombBox                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SyncDeadTombBoxToController(class APlayerTombBox* _DeadTombBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SyncDeadTombBoxToController");

	ASTExtraBaseCharacter_SyncDeadTombBoxToController_Params params;
	params._DeadTombBox = _DeadTombBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchWeaponBySlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForceFinishPreviousSwitch     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ignoreState                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ignoreCreatingWeapon           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SwitchWeaponBySlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bUseAnimation, bool bForceFinishPreviousSwitch, bool ignoreState, bool ignoreCreatingWeapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchWeaponBySlot");

	ASTExtraBaseCharacter_SwitchWeaponBySlot_Params params;
	params.Slot = Slot;
	params.bUseAnimation = bUseAnimation;
	params.bForceFinishPreviousSwitch = bForceFinishPreviousSwitch;
	params.ignoreState = ignoreState;
	params.ignoreCreatingWeapon = ignoreCreatingWeapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchToLastWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForceFinishPreviousSwitch     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SwitchToLastWeapon(bool bUseAnimation, bool bForceFinishPreviousSwitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchToLastWeapon");

	ASTExtraBaseCharacter_SwitchToLastWeapon_Params params;
	params.bUseAnimation = bUseAnimation;
	params.bForceFinishPreviousSwitch = bForceFinishPreviousSwitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchToLastNoneGrenageWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForceFinishPreviousSwitch     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SwitchToLastNoneGrenageWeapon(bool bUseAnimation, bool bForceFinishPreviousSwitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchToLastNoneGrenageWeapon");

	ASTExtraBaseCharacter_SwitchToLastNoneGrenageWeapon_Params params;
	params.bUseAnimation = bUseAnimation;
	params.bForceFinishPreviousSwitch = bForceFinishPreviousSwitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchPoseState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEPoseState>     State                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIgnoreCD                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIgnoreCheck                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ShouldShowPrompt               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsTriggerByPressBtn            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::SwitchPoseState(TEnumAsByte<ESTEPoseState> State, bool bIgnoreCD, bool bIgnoreCheck, bool ShouldShowPrompt, bool IsTriggerByPressBtn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SwitchPoseState");

	ASTExtraBaseCharacter_SwitchPoseState_Params params;
	params.State = State;
	params.bIgnoreCD = bIgnoreCD;
	params.bIgnoreCheck = bIgnoreCheck;
	params.ShouldShowPrompt = ShouldShowPrompt;
	params.IsTriggerByPressBtn = IsTriggerByPressBtn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SwapMainWeapon
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::SwapMainWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SwapMainWeapon");

	ASTExtraBaseCharacter_SwapMainWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.STServerUpdateState
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// float                          InThrottleInput                (Parm, ZeroConstructor, IsPlainOldData)
// float                          InSteeringInput                (Parm, ZeroConstructor, IsPlainOldData)
// int8_t                         State                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                ControlRotation                (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::STServerUpdateState(float InThrottleInput, float InSteeringInput, int8_t State, const struct FRotator& ControlRotation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.STServerUpdateState");

	ASTExtraBaseCharacter_STServerUpdateState_Params params;
	params.InThrottleInput = InThrottleInput;
	params.InSteeringInput = InSteeringInput;
	params.State = State;
	params.ControlRotation = ControlRotation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StopSlotAnim
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*       AnimSequence                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   SlotName                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          blendTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraBaseCharacter::StopSlotAnim(class UAnimSequenceBase* AnimSequence, const struct FName& SlotName, float blendTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StopSlotAnim");

	ASTExtraBaseCharacter_StopSlotAnim_Params params;
	params.AnimSequence = AnimSequence;
	params.SlotName = SlotName;
	params.blendTime = blendTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StopPlayEmoteAnim
// (Final, Native, Public)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::StopPlayEmoteAnim(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StopPlayEmoteAnim");

	ASTExtraBaseCharacter_StopPlayEmoteAnim_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StopFireFilter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::StopFireFilter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StopFireFilter");

	ASTExtraBaseCharacter_StopFireFilter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StopFire
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::StopFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StopFire");

	ASTExtraBaseCharacter_StopFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StartPlayEmoteAnim
// (Final, Native, Public)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::StartPlayEmoteAnim(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StartPlayEmoteAnim");

	ASTExtraBaseCharacter_StartPlayEmoteAnim_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StartFireSimple
// (Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::StartFireSimple()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StartFireSimple");

	ASTExtraBaseCharacter_StartFireSimple_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StartFireFilter
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::StartFireFilter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StartFireFilter");

	ASTExtraBaseCharacter_StartFireFilter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.StartFire
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// int                            BurstShootBulletsLimit         (Parm, ZeroConstructor, IsPlainOldData)
// float                          BurstShootTimeLimit            (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EShootWeaponShootMode> ShootMode                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 SimpleShootTarget              (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::StartFire(int BurstShootBulletsLimit, float BurstShootTimeLimit, TEnumAsByte<EShootWeaponShootMode> ShootMode, const struct FVector& SimpleShootTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.StartFire");

	ASTExtraBaseCharacter_StartFire_Params params;
	params.BurstShootBulletsLimit = BurstShootBulletsLimit;
	params.BurstShootTimeLimit = BurstShootTimeLimit;
	params.ShootMode = ShootMode;
	params.SimpleShootTarget = SimpleShootTarget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnFootprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EFootprintType                 FootprintType                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SpawnFootprint(EFootprintType FootprintType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnFootprint");

	ASTExtraBaseCharacter_SpawnFootprint_Params params;
	params.FootprintType = FootprintType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwithToGrenadeServerCall
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// TEnumAsByte<EGrenadeType>      grenadeType                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SpawnAndSwithToGrenadeServerCall(TEnumAsByte<EGrenadeType> grenadeType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwithToGrenadeServerCall");

	ASTExtraBaseCharacter_SpawnAndSwithToGrenadeServerCall_Params params;
	params.grenadeType = grenadeType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwitchToGrenadeOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   SpesificLogicGrenadeSlot       (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraBaseCharacter::SpawnAndSwitchToGrenadeOnServer(const struct FName& SpesificLogicGrenadeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwitchToGrenadeOnServer");

	ASTExtraBaseCharacter_SpawnAndSwitchToGrenadeOnServer_Params params;
	params.SpesificLogicGrenadeSlot = SpesificLogicGrenadeSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwitchToGrenadeOnClient
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   SpesificLogicGrenadeSlot       (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraBaseCharacter::SpawnAndSwitchToGrenadeOnClient(const struct FName& SpesificLogicGrenadeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndSwitchToGrenadeOnClient");

	ASTExtraBaseCharacter_SpawnAndSwitchToGrenadeOnClient_Params params;
	params.SpesificLogicGrenadeSlot = SpesificLogicGrenadeSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndBackpackWeaponOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                  Template                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FItemDefineID           ID                             (Parm)
// struct FName                   LogicSocket                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAutoUse                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bResetBulletNum                (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraBaseCharacter::SpawnAndBackpackWeaponOnServer(class UClass* Template, const struct FItemDefineID& ID, const struct FName& LogicSocket, bool bAutoUse, bool bResetBulletNum)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SpawnAndBackpackWeaponOnServer");

	ASTExtraBaseCharacter_SpawnAndBackpackWeaponOnServer_Params params;
	params.Template = Template;
	params.ID = ID;
	params.LogicSocket = LogicSocket;
	params.bAutoUse = bAutoUse;
	params.bResetBulletNum = bResetBulletNum;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShowNightVisionFrame
// (Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::ShowNightVisionFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShowNightVisionFrame");

	ASTExtraBaseCharacter_ShowNightVisionFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugRole
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraBaseCharacter::ShowDebugRole()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugRole");

	ASTExtraBaseCharacter_ShowDebugRole_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugRecordData
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraBaseCharacter::ShowDebugRecordData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugRecordData");

	ASTExtraBaseCharacter_ShowDebugRecordData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugPickUpFlow
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraBaseCharacter::ShowDebugPickUpFlow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugPickUpFlow");

	ASTExtraBaseCharacter_ShowDebugPickUpFlow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugEquipOrUnequipFlow
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraBaseCharacter::ShowDebugEquipOrUnequipFlow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShowDebugEquipOrUnequipFlow");

	ASTExtraBaseCharacter_ShowDebugEquipOrUnequipFlow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldUpdateHPOnUI
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ShouldUpdateHPOnUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldUpdateHPOnUI");

	ASTExtraBaseCharacter_ShouldUpdateHPOnUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldShowCorp
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ShouldShowCorp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldShowCorp");

	ASTExtraBaseCharacter_ShouldShowCorp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldShowAnchor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ShouldShowAnchor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldShowAnchor");

	ASTExtraBaseCharacter_ShouldShowAnchor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldAutoScopeWhenPeek
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ShouldAutoScopeWhenPeek()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ShouldAutoScopeWhenPeek");

	ASTExtraBaseCharacter_ShouldAutoScopeWhenPeek_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetWeaponShootType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> shootType                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetWeaponShootType(TEnumAsByte<ESTEWeaponShootType> shootType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetWeaponShootType");

	ASTExtraBaseCharacter_SetWeaponShootType_Params params;
	params.shootType = shootType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetViewTargetAgainForOB
// (Final, Native, Public)

void ASTExtraBaseCharacter::SetViewTargetAgainForOB()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetViewTargetAgainForOB");

	ASTExtraBaseCharacter_SetViewTargetAgainForOB_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetThrowGrenadeMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EThrowGrenadeMode> ThrowMode                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetThrowGrenadeMode(TEnumAsByte<EThrowGrenadeMode> ThrowMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetThrowGrenadeMode");

	ASTExtraBaseCharacter_SetThrowGrenadeMode_Params params;
	params.ThrowMode = ThrowMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetReloadMethod
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EWeaponReloadMethod> reloadMethod                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetReloadMethod(TEnumAsByte<EWeaponReloadMethod> reloadMethod)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetReloadMethod");

	ASTExtraBaseCharacter_SetReloadMethod_Params params;
	params.reloadMethod = reloadMethod;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetMyGiftGiverCandidate
// (Final, Native, Public)
// Parameters:
// class ASTExtraBaseCharacter*   candidate                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EUTGiftType>       GiftType                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetMyGiftGiverCandidate(class ASTExtraBaseCharacter* candidate, TEnumAsByte<EUTGiftType> GiftType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetMyGiftGiverCandidate");

	ASTExtraBaseCharacter_SetMyGiftGiverCandidate_Params params;
	params.candidate = candidate;
	params.GiftType = GiftType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetIsAutoFollow
// (Final, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   IFollowWho                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetIsAutoFollow(bool Val, class ASTExtraBaseCharacter* IFollowWho)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetIsAutoFollow");

	ASTExtraBaseCharacter_SetIsAutoFollow_Params params;
	params.Val = Val;
	params.IFollowWho = IFollowWho;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetHighWalkSpeed
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// float                          WalkSpeed                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetHighWalkSpeed(float WalkSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetHighWalkSpeed");

	ASTExtraBaseCharacter_SetHighWalkSpeed_Params params;
	params.WalkSpeed = WalkSpeed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetHealthSafety
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          NewHealth                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ERecoveryReasonType> Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetHealthSafety(float NewHealth, TEnumAsByte<ERecoveryReasonType> Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetHealthSafety");

	ASTExtraBaseCharacter_SetHealthSafety_Params params;
	params.NewHealth = NewHealth;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetHandFoldRatio
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Ratio                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetHandFoldRatio(int Ratio)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetHandFoldRatio");

	ASTExtraBaseCharacter_SetHandFoldRatio_Params params;
	params.Ratio = Ratio;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetExitingParachute
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ExitParachute                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetExitingParachute(bool ExitParachute)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetExitingParachute");

	ASTExtraBaseCharacter_SetExitingParachute_Params params;
	params.ExitParachute = ExitParachute;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetDelayStateSwitchTime
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DelayTime                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetDelayStateSwitchTime(float DelayTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetDelayStateSwitchTime");

	ASTExtraBaseCharacter_SetDelayStateSwitchTime_Params params;
	params.DelayTime = DelayTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetCurrentPersonPerspective
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsNewFPP                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsInitSetting                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::SetCurrentPersonPerspective(bool IsNewFPP, bool IsInitSetting)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetCurrentPersonPerspective");

	ASTExtraBaseCharacter_SetCurrentPersonPerspective_Params params;
	params.IsNewFPP = IsNewFPP;
	params.IsInitSetting = IsInitSetting;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetComponentsActive
// (Native, Public, BlueprintCallable)
// Parameters:
// class UClass*                  ComponentClass                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsActive                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetComponentsActive(class UClass* ComponentClass, bool IsActive)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetComponentsActive");

	ASTExtraBaseCharacter_SetComponentsActive_Params params;
	params.ComponentClass = ComponentClass;
	params.IsActive = IsActive;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetCheatSpeedModifier
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// float                          NewModifier                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetCheatSpeedModifier(float NewModifier)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetCheatSpeedModifier");

	ASTExtraBaseCharacter_SetCheatSpeedModifier_Params params;
	params.NewModifier = NewModifier;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimParamIsRescueing
// (Final, Native, Public)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetAnimParamIsRescueing(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimParamIsRescueing");

	ASTExtraBaseCharacter_SetAnimParamIsRescueing_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimParamIsNearDeathStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Val                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetAnimParamIsNearDeathStatus(bool Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimParamIsNearDeathStatus");

	ASTExtraBaseCharacter_SetAnimParamIsNearDeathStatus_Params params;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimMontagePlayRate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimMontage*            AnimMontage                    (Parm, ZeroConstructor, IsPlainOldData)
// float                          InPlayRate                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetAnimMontagePlayRate(class UAnimMontage* AnimMontage, float InPlayRate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetAnimMontagePlayRate");

	ASTExtraBaseCharacter_SetAnimMontagePlayRate_Params params;
	params.AnimMontage = AnimMontage;
	params.InPlayRate = InPlayRate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SetAmbientRTPC
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 RTPC                           (Parm, ZeroConstructor)
// float                          Value                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::SetAmbientRTPC(const struct FString& RTPC, float Value)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SetAmbientRTPC");

	ASTExtraBaseCharacter_SetAmbientRTPC_Params params;
	params.RTPC = RTPC;
	params.Value = Value;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerTriggerJump
// (Net, Native, Event, Public, NetServer, NetValidate)

void ASTExtraBaseCharacter::ServerTriggerJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerTriggerJump");

	ASTExtraBaseCharacter_ServerTriggerJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetPeekState
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           IsLeft                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ButtonDown                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerSetPeekState(bool IsLeft, bool ButtonDown)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetPeekState");

	ASTExtraBaseCharacter_ServerSetPeekState_Params params;
	params.IsLeft = IsLeft;
	params.ButtonDown = ButtonDown;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetPeekCollision
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           HasCollision                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerSetPeekCollision(bool HasCollision)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetPeekCollision");

	ASTExtraBaseCharacter_ServerSetPeekCollision_Params params;
	params.HasCollision = HasCollision;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetMovementState
// (Net, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 Input                          (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::ServerSetMovementState(const struct FVector& Input)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSetMovementState");

	ASTExtraBaseCharacter_ServerSetMovementState_Params params;
	params.Input = Input;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSendToLobbyServerUseItem
// (Final, Native, Public)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerSendToLobbyServerUseItem(int ItemID, int Count)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSendToLobbyServerUseItem");

	ASTExtraBaseCharacter_ServerSendToLobbyServerUseItem_Params params;
	params.ItemID = ItemID;
	params.Count = Count;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSendToLobbyServerUseGiftItem
// (Final, Native, Public)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   receiver                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerSendToLobbyServerUseGiftItem(int ItemID, int Count, class ASTExtraBaseCharacter* receiver)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerSendToLobbyServerUseGiftItem");

	ASTExtraBaseCharacter_ServerSendToLobbyServerUseGiftItem_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.receiver = receiver;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerResponseInvite
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FString                 SomeOne                        (Parm, ZeroConstructor)
// EInviteResponceType            res                            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           NotAllowInvitedLater           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerResponseInvite(const struct FString& SomeOne, EInviteResponceType res, bool NotAllowInvitedLater)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerResponseInvite");

	ASTExtraBaseCharacter_ServerResponseInvite_Params params;
	params.SomeOne = SomeOne;
	params.res = res;
	params.NotAllowInvitedLater = NotAllowInvitedLater;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerNightVisionUse
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// bool                           bUse                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerNightVisionUse(bool bUse)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerNightVisionUse");

	ASTExtraBaseCharacter_ServerNightVisionUse_Params params;
	params.bUse = bUse;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerInviteTeammate
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TArray<struct FString>         Names                          (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::ServerInviteTeammate(TArray<struct FString> Names)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerInviteTeammate");

	ASTExtraBaseCharacter_ServerInviteTeammate_Params params;
	params.Names = Names;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerFollowTeammate
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// struct FString                 Name                           (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::ServerFollowTeammate(const struct FString& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerFollowTeammate");

	ASTExtraBaseCharacter_ServerFollowTeammate_Params params;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerChangeThrowGrenadeMode
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<EThrowGrenadeMode> ThrowMode                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ServerChangeThrowGrenadeMode(TEnumAsByte<EThrowGrenadeMode> ThrowMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerChangeThrowGrenadeMode");

	ASTExtraBaseCharacter_ServerChangeThrowGrenadeMode_Params params;
	params.ThrowMode = ThrowMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ServerCancelFollow
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraBaseCharacter::ServerCancelFollow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ServerCancelFollow");

	ASTExtraBaseCharacter_ServerCancelFollow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SendServerMoveToClientUnreliaby
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Position                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FRotator                Rotation                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 Velocity                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::SendServerMoveToClientUnreliaby(float TimeStamp, const struct FVector& Position, const struct FRotator& Rotation, const struct FVector& Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SendServerMoveToClientUnreliaby");

	ASTExtraBaseCharacter_SendServerMoveToClientUnreliaby_Params params;
	params.TimeStamp = TimeStamp;
	params.Position = Position;
	params.Rotation = Rotation;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SendClientMoveToServerUnreliaby
// (Net, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Position                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FRotator                Rotation                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 Velocity                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::SendClientMoveToServerUnreliaby(float TimeStamp, const struct FVector& Position, const struct FRotator& Rotation, const struct FVector& Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SendClientMoveToServerUnreliaby");

	ASTExtraBaseCharacter_SendClientMoveToServerUnreliaby_Params params;
	params.TimeStamp = TimeStamp;
	params.Position = Position;
	params.Rotation = Rotation;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SendClientMoveToServerReliaby
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Position                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FRotator                Rotation                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 Velocity                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::SendClientMoveToServerReliaby(float TimeStamp, const struct FVector& Position, const struct FRotator& Rotation, const struct FVector& Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SendClientMoveToServerReliaby");

	ASTExtraBaseCharacter_SendClientMoveToServerReliaby_Params params;
	params.TimeStamp = TimeStamp;
	params.Position = Position;
	params.Rotation = Rotation;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SearchTombBoxes
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FSearchedTombBoxAndWrapperListResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FSearchedTombBoxAndWrapperListResult> ASTExtraBaseCharacter::SearchTombBoxes()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SearchTombBoxes");

	ASTExtraBaseCharacter_SearchTombBoxes_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SearchPickUpWrapperActors
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bIncludeWrapprsOnGround        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIncludeWrapprsInBox           (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FSearchedPickUpItemResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FSearchedPickUpItemResult> ASTExtraBaseCharacter::SearchPickUpWrapperActors(bool bIncludeWrapprsOnGround, bool bIncludeWrapprsInBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SearchPickUpWrapperActors");

	ASTExtraBaseCharacter_SearchPickUpWrapperActors_Params params;
	params.bIncludeWrapprsOnGround = bIncludeWrapprsOnGround;
	params.bIncludeWrapprsInBox = bIncludeWrapprsInBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Scoping
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Scoping(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Scoping");

	ASTExtraBaseCharacter_Scoping_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeOut
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ScopeOut(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeOut");

	ASTExtraBaseCharacter_ScopeOut_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeInterrupt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ScopeInterrupt(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeInterrupt");

	ASTExtraBaseCharacter_ScopeInterrupt_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESTEScopeType>     NewType                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ScopeIn(TEnumAsByte<ESTEScopeType> NewType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ScopeIn");

	ASTExtraBaseCharacter_ScopeIn_Params params;
	params.NewType = NewType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.SaveMeshUpdateFlag
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::SaveMeshUpdateFlag()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.SaveMeshUpdateFlag");

	ASTExtraBaseCharacter_SaveMeshUpdateFlag_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.S2C_InterruptState
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// int                            stateID                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            interruptedBy                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::S2C_InterruptState(int stateID, int interruptedBy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.S2C_InterruptState");

	ASTExtraBaseCharacter_S2C_InterruptState_Params params;
	params.stateID = stateID;
	params.interruptedBy = interruptedBy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SwitchWeapon
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForceFinishPreviousSwitch     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ignoreState                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ignoreCreatingWeapon           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Server_SwitchWeapon(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bUseAnimation, bool bForceFinishPreviousSwitch, bool ignoreState, bool ignoreCreatingWeapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SwitchWeapon");

	ASTExtraBaseCharacter_RPC_Server_SwitchWeapon_Params params;
	params.Slot = Slot;
	params.bUseAnimation = bUseAnimation;
	params.bForceFinishPreviousSwitch = bForceFinishPreviousSwitch;
	params.ignoreState = ignoreState;
	params.ignoreCreatingWeapon = ignoreCreatingWeapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SwapMainWeapon
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void ASTExtraBaseCharacter::RPC_Server_SwapMainWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SwapMainWeapon");

	ASTExtraBaseCharacter_RPC_Server_SwapMainWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SpawnAndSwitchToGrenade
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// struct FName                   SpesificLogicGrenadeSlot       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Server_SpawnAndSwitchToGrenade(const struct FName& SpesificLogicGrenadeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SpawnAndSwitchToGrenade");

	ASTExtraBaseCharacter_RPC_Server_SpawnAndSwitchToGrenade_Params params;
	params.SpesificLogicGrenadeSlot = SpesificLogicGrenadeSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SetHandFoldRatio
// (Net, NetReliable, Native, Event, Protected, NetServer, BlueprintCallable, NetValidate)
// Parameters:
// int                            Ratio                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Server_SetHandFoldRatio(int Ratio)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SetHandFoldRatio");

	ASTExtraBaseCharacter_RPC_Server_SetHandFoldRatio_Params params;
	params.Ratio = Ratio;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SetCurScopeFov
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// float                          InFov                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Server_SetCurScopeFov(float InFov)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_SetCurScopeFov");

	ASTExtraBaseCharacter_RPC_Server_SetCurScopeFov_Params params;
	params.InFov = InFov;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_EnableCurrentWeaponInfiniteBullets
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Server_EnableCurrentWeaponInfiniteBullets(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_EnableCurrentWeaponInfiniteBullets");

	ASTExtraBaseCharacter_RPC_Server_EnableCurrentWeaponInfiniteBullets_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_DestroyGrenadeAndSwitchBackToPreviousWeapon
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void ASTExtraBaseCharacter::RPC_Server_DestroyGrenadeAndSwitchBackToPreviousWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Server_DestroyGrenadeAndSwitchBackToPreviousWeapon");

	ASTExtraBaseCharacter_RPC_Server_DestroyGrenadeAndSwitchBackToPreviousWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_NetMulticast_HandlePlayerPickUpActor
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          TargetZLoc                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_NetMulticast_HandlePlayerPickUpActor(float TargetZLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_NetMulticast_HandlePlayerPickUpActor");

	ASTExtraBaseCharacter_RPC_NetMulticast_HandlePlayerPickUpActor_Params params;
	params.TargetZLoc = TargetZLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_CollideByTeamMate
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   pOtherChar                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_CollideByTeamMate(class ASTExtraBaseCharacter* pOtherChar)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_CollideByTeamMate");

	ASTExtraBaseCharacter_RPC_CollideByTeamMate_Params params;
	params.pOtherChar = pOtherChar;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_ClientSimpleDamageCache
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// TArray<struct FSimpleDamageRepData> DamageData                     (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::RPC_ClientSimpleDamageCache(TArray<struct FSimpleDamageRepData> DamageData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_ClientSimpleDamageCache");

	ASTExtraBaseCharacter_RPC_ClientSimpleDamageCache_Params params;
	params.DamageData = DamageData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SwitchWeapon
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bUseAnimation                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForceFinishPreviousSwitch     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ignoreState                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_SwitchWeapon(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bUseAnimation, bool bForceFinishPreviousSwitch, bool ignoreState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SwitchWeapon");

	ASTExtraBaseCharacter_RPC_Client_SwitchWeapon_Params params;
	params.Slot = Slot;
	params.bUseAnimation = bUseAnimation;
	params.bForceFinishPreviousSwitch = bForceFinishPreviousSwitch;
	params.ignoreState = ignoreState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SwapMainWeapon
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)

void ASTExtraBaseCharacter::RPC_Client_SwapMainWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SwapMainWeapon");

	ASTExtraBaseCharacter_RPC_Client_SwapMainWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SpawnAndSwitchToGrenade
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// struct FName                   SpesificLogicGrenadeSlot       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_SpawnAndSwitchToGrenade(const struct FName& SpesificLogicGrenadeSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SpawnAndSwitchToGrenade");

	ASTExtraBaseCharacter_RPC_Client_SpawnAndSwitchToGrenade_Params params;
	params.SpesificLogicGrenadeSlot = SpesificLogicGrenadeSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_ShootVertifyRes
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// TEnumAsByte<EShootVertifyRes>  VertifyRes                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FBulletHitInfoUploadData HistoryShootData               (ConstParm, Parm, ReferenceParm)
// struct FCharacterHistoryData   HistoryChData                  (ConstParm, Parm, ReferenceParm)

void ASTExtraBaseCharacter::RPC_Client_ShootVertifyRes(TEnumAsByte<EShootVertifyRes> VertifyRes, const struct FBulletHitInfoUploadData& HistoryShootData, const struct FCharacterHistoryData& HistoryChData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_ShootVertifyRes");

	ASTExtraBaseCharacter_RPC_Client_ShootVertifyRes_Params params;
	params.VertifyRes = VertifyRes;
	params.HistoryShootData = HistoryShootData;
	params.HistoryChData = HistoryChData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SetReloadCurWeapon
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_SetReloadCurWeapon(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_SetReloadCurWeapon");

	ASTExtraBaseCharacter_RPC_Client_SetReloadCurWeapon_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_ReportPlayerKillFlow
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// class ASTExtraBaseCharacter*   killedPlayer                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_ReportPlayerKillFlow(class ASTExtraBaseCharacter* killedPlayer)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_ReportPlayerKillFlow");

	ASTExtraBaseCharacter_RPC_Client_ReportPlayerKillFlow_Params params;
	params.killedPlayer = killedPlayer;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnNearDeathRecordingNotify
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// struct FString                 SpectatorName                  (Parm, ZeroConstructor)
// bool                           bSpectatorIsAI                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_OnNearDeathRecordingNotify(const struct FString& SpectatorName, bool bSpectatorIsAI)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnNearDeathRecordingNotify");

	ASTExtraBaseCharacter_RPC_Client_OnNearDeathRecordingNotify_Params params;
	params.SpectatorName = SpectatorName;
	params.bSpectatorIsAI = bSpectatorIsAI;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnDeathStopRecordingNotify
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// struct FString                 SpectatorName                  (Parm, ZeroConstructor)
// bool                           bSpectatorIsAI                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForce                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_OnDeathStopRecordingNotify(const struct FString& SpectatorName, bool bSpectatorIsAI, bool bForce)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnDeathStopRecordingNotify");

	ASTExtraBaseCharacter_RPC_Client_OnDeathStopRecordingNotify_Params params;
	params.SpectatorName = SpectatorName;
	params.bSpectatorIsAI = bSpectatorIsAI;
	params.bForce = bForce;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnDamageNotifyRecord
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// int                            DamagerID                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAI                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          fHealth                        (Parm, ZeroConstructor, IsPlainOldData)
// int                            OtherHealthStatus              (Parm, ZeroConstructor, IsPlainOldData)
// float                          ShootDistance                  (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   causerName                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_OnDamageNotifyRecord(int DamagerID, bool bAI, float fHealth, int OtherHealthStatus, float ShootDistance, int DamageType, const struct FName& causerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_OnDamageNotifyRecord");

	ASTExtraBaseCharacter_RPC_Client_OnDamageNotifyRecord_Params params;
	params.DamagerID = DamagerID;
	params.bAI = bAI;
	params.fHealth = fHealth;
	params.OtherHealthStatus = OtherHealthStatus;
	params.ShootDistance = ShootDistance;
	params.DamageType = DamageType;
	params.causerName = causerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_EnableCurrentWeaponInfiniteBullets
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RPC_Client_EnableCurrentWeaponInfiniteBullets(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_EnableCurrentWeaponInfiniteBullets");

	ASTExtraBaseCharacter_RPC_Client_EnableCurrentWeaponInfiniteBullets_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_DestroyGrenadeAndSwitchBackToPreviousWeapon
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)

void ASTExtraBaseCharacter::RPC_Client_DestroyGrenadeAndSwitchBackToPreviousWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RPC_Client_DestroyGrenadeAndSwitchBackToPreviousWeapon");

	ASTExtraBaseCharacter_RPC_Client_DestroyGrenadeAndSwitchBackToPreviousWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RestoreMeshUpdateFlag
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::RestoreMeshUpdateFlag()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RestoreMeshUpdateFlag");

	ASTExtraBaseCharacter_RestoreMeshUpdateFlag_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ResponceInvite
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 SomeOne                        (Parm, ZeroConstructor)
// EInviteResponceType            res                            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           NotAllowInvitedLater           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ResponceInvite(const struct FString& SomeOne, EInviteResponceType res, bool NotAllowInvitedLater)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ResponceInvite");

	ASTExtraBaseCharacter_ResponceInvite_Params params;
	params.SomeOne = SomeOne;
	params.res = res;
	params.NotAllowInvitedLater = NotAllowInvitedLater;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ResetValueLimitForHealthPredict
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::ResetValueLimitForHealthPredict()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ResetValueLimitForHealthPredict");

	ASTExtraBaseCharacter_ResetValueLimitForHealthPredict_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ResetCharacterEnergy
// (Final, Native, Public)

void ASTExtraBaseCharacter::ResetCharacterEnergy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ResetCharacterEnergy");

	ASTExtraBaseCharacter_ResetCharacterEnergy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ResetCamera
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::ResetCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ResetCamera");

	ASTExtraBaseCharacter_ResetCamera_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RequestUserCancleRescue
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraBaseCharacter::RequestUserCancleRescue()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RequestUserCancleRescue");

	ASTExtraBaseCharacter_RequestUserCancleRescue_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReqStartPlayEmote
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ReqStartPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReqStartPlayEmote");

	ASTExtraBaseCharacter_ReqStartPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReqInteruptPlayEmote
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ReqInteruptPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReqInteruptPlayEmote");

	ASTExtraBaseCharacter_ReqInteruptPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReqEmotePlayFinished
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ReqEmotePlayFinished(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReqEmotePlayFinished");

	ASTExtraBaseCharacter_ReqEmotePlayFinished_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReportAntiCheatInfo
// (Final, Native, Public)

void ASTExtraBaseCharacter::ReportAntiCheatInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReportAntiCheatInfo");

	ASTExtraBaseCharacter_ReportAntiCheatInfo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReloadWeaponFilter
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ReloadWeaponFilter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReloadWeaponFilter");

	ASTExtraBaseCharacter_ReloadWeaponFilter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ReloadCurrentWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::ReloadCurrentWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ReloadCurrentWeapon");

	ASTExtraBaseCharacter_ReloadCurrentWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RegisterPlayerPickUpList
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraBaseCharacter::RegisterPlayerPickUpList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RegisterPlayerPickUpList");

	ASTExtraBaseCharacter_RegisterPlayerPickUpList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshPersonPerspective
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::RefreshPersonPerspective()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshPersonPerspective");

	ASTExtraBaseCharacter_RefreshPersonPerspective_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshMoveAttrModifier
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::RefreshMoveAttrModifier()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshMoveAttrModifier");

	ASTExtraBaseCharacter_RefreshMoveAttrModifier_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshAvatar
// (Final, Native, Public)
// Parameters:
// EAvatarSlotType                slotType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isEquipped                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::RefreshAvatar(EAvatarSlotType slotType, bool isEquipped)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.RefreshAvatar");

	ASTExtraBaseCharacter_RefreshAvatar_Params params;
	params.slotType = slotType;
	params.isEquipped = isEquipped;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PrintAIPolicyDecisionData
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PrintAIPolicyDecisionData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PrintAIPolicyDecisionData");

	ASTExtraBaseCharacter_PrintAIPolicyDecisionData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PostGetPlayerAnimation
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::PostGetPlayerAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PostGetPlayerAnimation");

	ASTExtraBaseCharacter_PostGetPlayerAnimation_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySwitchSightSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlaySwitchSightSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySwitchSightSound");

	ASTExtraBaseCharacter_PlaySwitchSightSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySwitchFireModeSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlaySwitchFireModeSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySwitchFireModeSound");

	ASTExtraBaseCharacter_PlaySwitchFireModeSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySpecialAmbientSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*           TargetSound                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::PlaySpecialAmbientSound(class UAkAudioEvent* TargetSound)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySpecialAmbientSound");

	ASTExtraBaseCharacter_PlaySpecialAmbientSound_Params params;
	params.TargetSound = TargetSound;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySlotAnim
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*       AnimSequence                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   SlotName                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          InPlayRate                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          blendTime                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraBaseCharacter::PlaySlotAnim(class UAnimSequenceBase* AnimSequence, const struct FName& SlotName, float InPlayRate, float blendTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySlotAnim");

	ASTExtraBaseCharacter_PlaySlotAnim_Params params;
	params.AnimSequence = AnimSequence;
	params.SlotName = SlotName;
	params.InPlayRate = InPlayRate;
	params.blendTime = blendTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySelfThrowAwayWeaponSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlaySelfThrowAwayWeaponSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlaySelfThrowAwayWeaponSound");

	ASTExtraBaseCharacter_PlaySelfThrowAwayWeaponSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayPullBoltSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayPullBoltSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayPullBoltSound");

	ASTExtraBaseCharacter_PlayPullBoltSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayOperateItemSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 BankName                       (Parm, ZeroConstructor)
// struct FString                 SoundName                      (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::PlayOperateItemSound(const struct FString& BankName, const struct FString& SoundName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayOperateItemSound");

	ASTExtraBaseCharacter_PlayOperateItemSound_Params params;
	params.BankName = BankName;
	params.SoundName = SoundName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMountAccessoriesSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayMountAccessoriesSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMountAccessoriesSound");

	ASTExtraBaseCharacter_PlayMountAccessoriesSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMagOUTSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayMagOUTSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMagOUTSound");

	ASTExtraBaseCharacter_PlayMagOUTSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMagINSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayMagINSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayMagINSound");

	ASTExtraBaseCharacter_PlayMagINSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayLocalShellDropFX
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayLocalShellDropFX()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayLocalShellDropFX");

	ASTExtraBaseCharacter_PlayLocalShellDropFX_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayLoadBulletSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayLoadBulletSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayLoadBulletSound");

	ASTExtraBaseCharacter_PlayLoadBulletSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayFootstepSound
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EFootStepState>    FootStepState                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::PlayFootstepSound(TEnumAsByte<EFootStepState> FootStepState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayFootstepSound");

	ASTExtraBaseCharacter_PlayFootstepSound_Params params;
	params.FootStepState = FootStepState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayerConfirmToRescue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::PlayerConfirmToRescue()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayerConfirmToRescue");

	ASTExtraBaseCharacter_PlayerConfirmToRescue_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayChangeMagazineSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayChangeMagazineSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayChangeMagazineSound");

	ASTExtraBaseCharacter_PlayChangeMagazineSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PlayAmbientSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::PlayAmbientSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PlayAmbientSound");

	ASTExtraBaseCharacter_PlayAmbientSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PickUpWrapperActor
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FPickUpItemData         ItemData                       (ConstParm, Parm, OutParm, ReferenceParm)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::PickUpWrapperActor(class AActor* Target, const struct FPickUpItemData& ItemData, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PickUpWrapperActor");

	ASTExtraBaseCharacter_PickUpWrapperActor_Params params;
	params.Target = Target;
	params.ItemData = ItemData;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PickUpActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            pickCount                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::PickUpActor(class AActor* Target, int AdditionalParam, int pickCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PickUpActor");

	ASTExtraBaseCharacter_PickUpActor_Params params;
	params.Target = Target;
	params.AdditionalParam = AdditionalParam;
	params.pickCount = pickCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultServerCPP
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, BlueprintCallable, NetValidate)
// Parameters:
// float                          dis                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Length                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 VaultKey                       (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// struct FVector                 startPos                       (Parm, IsPlainOldData)
// class AActor*                  checkActor                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxFall              (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxDis               (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 hitpoint                       (Parm, IsPlainOldData)
// class AActor*                  WindowActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                MoveDir                        (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::PawnVaultServerCPP(float dis, float Height, float Length, const struct FString& VaultKey, const struct FVector& startPos, class AActor* checkActor, float crossblockMaxFall, float crossblockMaxDis, const struct FVector& hitpoint, class AActor* WindowActor, const struct FRotator& MoveDir)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultServerCPP");

	ASTExtraBaseCharacter_PawnVaultServerCPP_Params params;
	params.dis = dis;
	params.Height = Height;
	params.Length = Length;
	params.VaultKey = VaultKey;
	params.startPos = startPos;
	params.checkActor = checkActor;
	params.crossblockMaxFall = crossblockMaxFall;
	params.crossblockMaxDis = crossblockMaxDis;
	params.hitpoint = hitpoint;
	params.WindowActor = WindowActor;
	params.MoveDir = MoveDir;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultServerBluePrint
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// float                          dis                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Length                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 VaultKey                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 startPos                       (Parm, IsPlainOldData)
// class AActor*                  checkActor                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxFall              (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxDis               (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 hitpoint                       (Parm, IsPlainOldData)
// class AActor*                  WindowActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                MoveDir                        (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::PawnVaultServerBluePrint(float dis, float Height, float Length, const struct FString& VaultKey, const struct FVector& startPos, class AActor* checkActor, float crossblockMaxFall, float crossblockMaxDis, const struct FVector& hitpoint, class AActor* WindowActor, const struct FRotator& MoveDir)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultServerBluePrint");

	ASTExtraBaseCharacter_PawnVaultServerBluePrint_Params params;
	params.dis = dis;
	params.Height = Height;
	params.Length = Length;
	params.VaultKey = VaultKey;
	params.startPos = startPos;
	params.checkActor = checkActor;
	params.crossblockMaxFall = crossblockMaxFall;
	params.crossblockMaxDis = crossblockMaxDis;
	params.hitpoint = hitpoint;
	params.WindowActor = WindowActor;
	params.MoveDir = MoveDir;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultAllCPP
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                          dis                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Length                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 VaultKey                       (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// struct FVector                 startPos                       (Parm, IsPlainOldData)
// class AActor*                  checkActor                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxFall              (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxDis               (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 hitpoint                       (Parm, IsPlainOldData)
// struct FRotator                MoveDir                        (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::PawnVaultAllCPP(float dis, float Height, float Length, const struct FString& VaultKey, const struct FVector& startPos, class AActor* checkActor, float crossblockMaxFall, float crossblockMaxDis, const struct FVector& hitpoint, const struct FRotator& MoveDir)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultAllCPP");

	ASTExtraBaseCharacter_PawnVaultAllCPP_Params params;
	params.dis = dis;
	params.Height = Height;
	params.Length = Length;
	params.VaultKey = VaultKey;
	params.startPos = startPos;
	params.checkActor = checkActor;
	params.crossblockMaxFall = crossblockMaxFall;
	params.crossblockMaxDis = crossblockMaxDis;
	params.hitpoint = hitpoint;
	params.MoveDir = MoveDir;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultAllBluePrint
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// float                          dis                            (Parm, ZeroConstructor, IsPlainOldData)
// float                          Height                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Length                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 VaultKey                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 startPos                       (Parm, IsPlainOldData)
// class AActor*                  checkActor                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxFall              (Parm, ZeroConstructor, IsPlainOldData)
// float                          crossblockMaxDis               (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 hitpoint                       (Parm, IsPlainOldData)
// struct FRotator                MoveDir                        (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::PawnVaultAllBluePrint(float dis, float Height, float Length, const struct FString& VaultKey, const struct FVector& startPos, class AActor* checkActor, float crossblockMaxFall, float crossblockMaxDis, const struct FVector& hitpoint, const struct FRotator& MoveDir)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.PawnVaultAllBluePrint");

	ASTExtraBaseCharacter_PawnVaultAllBluePrint_Params params;
	params.dis = dis;
	params.Height = Height;
	params.Length = Length;
	params.VaultKey = VaultKey;
	params.startPos = startPos;
	params.checkActor = checkActor;
	params.crossblockMaxFall = crossblockMaxFall;
	params.crossblockMaxDis = crossblockMaxDis;
	params.hitpoint = hitpoint;
	params.MoveDir = MoveDir;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OpenWorldPawnCollision
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OpenWorldPawnCollision()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OpenWorldPawnCollision");

	ASTExtraBaseCharacter_OpenWorldPawnCollision_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnWeaponEquipmentUpdate
// (Native, Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::OnWeaponEquipmentUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnWeaponEquipmentUpdate");

	ASTExtraBaseCharacter_OnWeaponEquipmentUpdate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnUnEquipWeapon
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::OnUnEquipWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnUnEquipWeapon");

	ASTExtraBaseCharacter_OnUnEquipWeapon_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnStopFire
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::OnStopFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnStopFire");

	ASTExtraBaseCharacter_OnStopFire_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnStateLeave
// (Final, Native, Public)
// Parameters:
// EPawnState                     EnteredState                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnStateLeave(EPawnState EnteredState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnStateLeave");

	ASTExtraBaseCharacter_OnStateLeave_Params params;
	params.EnteredState = EnteredState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnStateEnter
// (Final, Native, Public)
// Parameters:
// EPawnState                     EnteredState                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnStateEnter(EPawnState EnteredState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnStateEnter");

	ASTExtraBaseCharacter_OnStateEnter_Params params;
	params.EnteredState = EnteredState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnStartFire
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> isAuto                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnStartFire(TEnumAsByte<ESTEWeaponShootType> isAuto)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnStartFire");

	ASTExtraBaseCharacter_OnStartFire_Params params;
	params.isAuto = isAuto;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnSleepByBorth
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OnSleepByBorth()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnSleepByBorth");

	ASTExtraBaseCharacter_OnSleepByBorth_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnShowName
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           _IsShow                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 _Name                          (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::OnShowName(bool _IsShow, const struct FString& _Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnShowName");

	ASTExtraBaseCharacter_OnShowName_Params params;
	params._IsShow = _IsShow;
	params._Name = _Name;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnScopeNotHandFold
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OnScopeNotHandFold()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnScopeNotHandFold");

	ASTExtraBaseCharacter_OnScopeNotHandFold_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnScopeHandFold
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OnScopeHandFold()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnScopeHandFold");

	ASTExtraBaseCharacter_OnScopeHandFold_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_VehicleSeatIdx
// (Final, Native, Protected)

void ASTExtraBaseCharacter::OnRep_VehicleSeatIdx()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_VehicleSeatIdx");

	ASTExtraBaseCharacter_OnRep_VehicleSeatIdx_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ThrowGrenadeMode
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_ThrowGrenadeMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ThrowGrenadeMode");

	ASTExtraBaseCharacter_OnRep_ThrowGrenadeMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_Temperature
// (Native, Protected)

void ASTExtraBaseCharacter::OnRep_Temperature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_Temperature");

	ASTExtraBaseCharacter_OnRep_Temperature_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_StatusChanged
// (Final, Native, Protected)
// Parameters:
// TEnumAsByte<ECharacterHealthStatus> prevStatus                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnRep_StatusChanged(TEnumAsByte<ECharacterHealthStatus> prevStatus)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_StatusChanged");

	ASTExtraBaseCharacter_OnRep_StatusChanged_Params params;
	params.prevStatus = prevStatus;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_SimpleDamageData
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_SimpleDamageData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_SimpleDamageData");

	ASTExtraBaseCharacter_OnRep_SimpleDamageData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ScopeFov
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_ScopeFov()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ScopeFov");

	ASTExtraBaseCharacter_OnRep_ScopeFov_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedParachuteState
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_ReplicatedParachuteState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedParachuteState");

	ASTExtraBaseCharacter_OnRep_ReplicatedParachuteState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedMoveState
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_ReplicatedMoveState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedMoveState");

	ASTExtraBaseCharacter_OnRep_ReplicatedMoveState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedIsStartParachute
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_ReplicatedIsStartParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_ReplicatedIsStartParachute");

	ASTExtraBaseCharacter_OnRep_ReplicatedIsStartParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PoseStateNotify
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastState                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnRep_PoseStateNotify(TEnumAsByte<ESTEPoseState> LastState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PoseStateNotify");

	ASTExtraBaseCharacter_OnRep_PoseStateNotify_Params params;
	params.LastState = LastState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PlayerName
// (Final, Native, Private)

void ASTExtraBaseCharacter::OnRep_PlayerName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PlayerName");

	ASTExtraBaseCharacter_OnRep_PlayerName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PlayerKey
// (Final, Native, Private)

void ASTExtraBaseCharacter::OnRep_PlayerKey()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PlayerKey");

	ASTExtraBaseCharacter_OnRep_PlayerKey_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PeekHasCollision
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_PeekHasCollision()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_PeekHasCollision");

	ASTExtraBaseCharacter_OnRep_PeekHasCollision_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_MoneyNotify
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_MoneyNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_MoneyNotify");

	ASTExtraBaseCharacter_OnRep_MoneyNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_KillTipsNotify
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_KillTipsNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_KillTipsNotify");

	ASTExtraBaseCharacter_OnRep_KillTipsNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsRescueingOtherStatusChange
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_IsRescueingOtherStatusChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsRescueingOtherStatusChange");

	ASTExtraBaseCharacter_OnRep_IsRescueingOtherStatusChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsInvincible
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_IsInvincible()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsInvincible");

	ASTExtraBaseCharacter_OnRep_IsInvincible_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsFPPChanged
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OnRep_IsFPPChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsFPPChanged");

	ASTExtraBaseCharacter_OnRep_IsFPPChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsBeingRescuedStatusChange
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_IsBeingRescuedStatusChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_IsBeingRescuedStatusChange");

	ASTExtraBaseCharacter_OnRep_IsBeingRescuedStatusChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_HealthPredict
// (Final, Native, Protected)

void ASTExtraBaseCharacter::OnRep_HealthPredict()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_HealthPredict");

	ASTExtraBaseCharacter_OnRep_HealthPredict_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_Health
// (Native, Protected)

void ASTExtraBaseCharacter::OnRep_Health()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_Health");

	ASTExtraBaseCharacter_OnRep_Health_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_HandFolderRatio
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_HandFolderRatio()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_HandFolderRatio");

	ASTExtraBaseCharacter_OnRep_HandFolderRatio_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_GiftGiverCandidateTypeChanged
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_GiftGiverCandidateTypeChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_GiftGiverCandidateTypeChanged");

	ASTExtraBaseCharacter_OnRep_GiftGiverCandidateTypeChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_GiftGiverCandidateChanged
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_GiftGiverCandidateChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_GiftGiverCandidateChanged");

	ASTExtraBaseCharacter_OnRep_GiftGiverCandidateChanged_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_FollowState
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_FollowState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_FollowState");

	ASTExtraBaseCharacter_OnRep_FollowState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_EnergyChange
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_EnergyChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_EnergyChange");

	ASTExtraBaseCharacter_OnRep_EnergyChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CurrentVehicle
// (Final, Native, Public)
// Parameters:
// class ASTExtraVehicleBase*     LastVehicle                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnRep_CurrentVehicle(class ASTExtraVehicleBase* LastVehicle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CurrentVehicle");

	ASTExtraBaseCharacter_OnRep_CurrentVehicle_Params params;
	params.LastVehicle = LastVehicle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CurrentStates
// (Final, Native, Private)
// Parameters:
// uint64_t                       prevStates                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnRep_CurrentStates(uint64_t prevStates)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CurrentStates");

	ASTExtraBaseCharacter_OnRep_CurrentStates_Params params;
	params.prevStates = prevStates;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CharacterFallingVelocityZFactor
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_CharacterFallingVelocityZFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_CharacterFallingVelocityZFactor");

	ASTExtraBaseCharacter_OnRep_CharacterFallingVelocityZFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_BreathAmmountChange
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_BreathAmmountChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_BreathAmmountChange");

	ASTExtraBaseCharacter_OnRep_BreathAmmountChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_bNightVisionUseTest
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_bNightVisionUseTest()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_bNightVisionUseTest");

	ASTExtraBaseCharacter_OnRep_bNightVisionUseTest_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_bNightVisionUse
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_bNightVisionUse()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_bNightVisionUse");

	ASTExtraBaseCharacter_OnRep_bNightVisionUse_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_AnchorPlat
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_AnchorPlat()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_AnchorPlat");

	ASTExtraBaseCharacter_OnRep_AnchorPlat_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_AKEventNotify
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnRep_AKEventNotify()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnRep_AKEventNotify");

	ASTExtraBaseCharacter_OnRep_AKEventNotify_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnPoseStateChange
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastState                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     CurState                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnPoseStateChange(TEnumAsByte<ESTEPoseState> LastState, TEnumAsByte<ESTEPoseState> CurState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnPoseStateChange");

	ASTExtraBaseCharacter_OnPoseStateChange_Params params;
	params.LastState = LastState;
	params.CurState = CurState;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnPlayEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            EmoteId                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnPlayEmote(int EmoteId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnPlayEmote");

	ASTExtraBaseCharacter_OnPlayEmote_Params params;
	params.EmoteId = EmoteId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnOpenDoor
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class APUBGDoor*               door                           (Parm, ZeroConstructor, IsPlainOldData)
// int                            doorState                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnOpenDoor(class APUBGDoor* door, int doorState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnOpenDoor");

	ASTExtraBaseCharacter_OnOpenDoor_Params params;
	params.door = door;
	params.doorState = doorState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnNotifyHurt
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::OnNotifyHurt()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnNotifyHurt");

	ASTExtraBaseCharacter_OnNotifyHurt_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnInterruptCurrentEmote
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::OnInterruptCurrentEmote()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnInterruptCurrentEmote");

	ASTExtraBaseCharacter_OnInterruptCurrentEmote_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnFollowStateChange
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnFollowStateChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnFollowStateChange");

	ASTExtraBaseCharacter_OnFollowStateChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnEquipWeapon
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnEquipWeapon(TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnEquipWeapon");

	ASTExtraBaseCharacter_OnEquipWeapon_Params params;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnEndCurrentEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            StopReason                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnEndCurrentEmote(int EmoteIndex, int StopReason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnEndCurrentEmote");

	ASTExtraBaseCharacter_OnEndCurrentEmote_Params params;
	params.EmoteIndex = EmoteIndex;
	params.StopReason = StopReason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnCurEquipedShootWeaponChangeState
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EFreshWeaponStateType> State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::OnCurEquipedShootWeaponChangeState(TEnumAsByte<EFreshWeaponStateType> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnCurEquipedShootWeaponChangeState");

	ASTExtraBaseCharacter_OnCurEquipedShootWeaponChangeState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnBPMoneyChange
// (Event, Protected, BlueprintEvent)

void ASTExtraBaseCharacter::OnBPMoneyChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnBPMoneyChange");

	ASTExtraBaseCharacter_OnBPMoneyChange_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnBPHealthChange
// (Event, Protected, BlueprintEvent)

void ASTExtraBaseCharacter::OnBPHealthChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnBPHealthChange");

	ASTExtraBaseCharacter_OnBPHealthChange_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnBeforeGetUp
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::OnBeforeGetUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnBeforeGetUp");

	ASTExtraBaseCharacter_OnBeforeGetUp_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnAsyncLoadEmoteAnim
// (Final, Native, Public)

void ASTExtraBaseCharacter::OnAsyncLoadEmoteAnim()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnAsyncLoadEmoteAnim");

	ASTExtraBaseCharacter_OnAsyncLoadEmoteAnim_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.OnActorHitHandle
// (Final, Native, Private, HasOutParms, HasDefaults)
// Parameters:
// class AActor*                  SelfActor                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::OnActorHitHandle(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.OnActorHitHandle");

	ASTExtraBaseCharacter_OnActorHitHandle_Params params;
	params.SelfActor = SelfActor;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.NM_SetPeekState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsLeft                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::NM_SetPeekState(bool Enable, bool IsLeft)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.NM_SetPeekState");

	ASTExtraBaseCharacter_NM_SetPeekState_Params params;
	params.Enable = Enable;
	params.IsLeft = IsLeft;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastStartPlayEmote
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::MulticastStartPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastStartPlayEmote");

	ASTExtraBaseCharacter_MulticastStartPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastInteruptPlayEmoteOnServer
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::MulticastInteruptPlayEmoteOnServer(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastInteruptPlayEmoteOnServer");

	ASTExtraBaseCharacter_MulticastInteruptPlayEmoteOnServer_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastInteruptPlayEmote
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::MulticastInteruptPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MulticastInteruptPlayEmote");

	ASTExtraBaseCharacter_MulticastInteruptPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeServer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void ASTExtraBaseCharacter::MeleeServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeServer");

	ASTExtraBaseCharacter_MeleeServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeReleased
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::MeleeReleased()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeReleased");

	ASTExtraBaseCharacter_MeleeReleased_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeLocal
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::MeleeLocal()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeLocal");

	ASTExtraBaseCharacter_MeleeLocal_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeBroadcastOtherClients
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)

void ASTExtraBaseCharacter::MeleeBroadcastOtherClients()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.MeleeBroadcastOtherClients");

	ASTExtraBaseCharacter_MeleeBroadcastOtherClients_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Melee
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsForCE                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Melee(bool IsForCE)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Melee");

	ASTExtraBaseCharacter_Melee_Params params;
	params.IsForCE = IsForCE;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LogWeaponsDataInWeaponManagerAndBackpack
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::LogWeaponsDataInWeaponManagerAndBackpack()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LogWeaponsDataInWeaponManagerAndBackpack");

	ASTExtraBaseCharacter_LogWeaponsDataInWeaponManagerAndBackpack_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LocalUnEquipWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::LocalUnEquipWeapon(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LocalUnEquipWeapon");

	ASTExtraBaseCharacter_LocalUnEquipWeapon_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LocalSwitchPersonPerspective
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           IsNewFPP                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsUseLerp                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsForceSwitch                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::LocalSwitchPersonPerspective(bool IsNewFPP, bool IsUseLerp, bool IsForceSwitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LocalSwitchPersonPerspective");

	ASTExtraBaseCharacter_LocalSwitchPersonPerspective_Params params;
	params.IsNewFPP = IsNewFPP;
	params.IsUseLerp = IsUseLerp;
	params.IsForceSwitch = IsForceSwitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LocalStartPlayEmote
// (Final, Native, Public)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::LocalStartPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LocalStartPlayEmote");

	ASTExtraBaseCharacter_LocalStartPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LocalInteruptPlayEmote
// (Final, Native, Public)
// Parameters:
// int                            EmoteIndex                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::LocalInteruptPlayEmote(int EmoteIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LocalInteruptPlayEmote");

	ASTExtraBaseCharacter_LocalInteruptPlayEmote_Params params;
	params.EmoteIndex = EmoteIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LocalEquipWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::LocalEquipWeapon(class ASTExtraWeapon* Weapon, TEnumAsByte<ESurviveWeaponPropSlot> Slot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LocalEquipWeapon");

	ASTExtraBaseCharacter_LocalEquipWeapon_Params params;
	params.Weapon = Weapon;
	params.Slot = Slot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LeaveState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::LeaveState(EPawnState State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LeaveState");

	ASTExtraBaseCharacter_LeaveState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.LeaveServerState
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::LeaveServerState(EPawnState State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.LeaveServerState");

	ASTExtraBaseCharacter_LeaveServerState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsUsingGrenade
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsUsingGrenade()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsUsingGrenade");

	ASTExtraBaseCharacter_IsUsingGrenade_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameTeamWithPlayerState
// (Final, Native, Public)
// Parameters:
// class APlayerState*            otherPS                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsSameTeamWithPlayerState(class APlayerState* otherPS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameTeamWithPlayerState");

	ASTExtraBaseCharacter_IsSameTeamWithPlayerState_Params params;
	params.otherPS = otherPS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameTeam
// (Native, Public)
// Parameters:
// class APawn*                   Other                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsSameTeam(class APawn* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameTeam");

	ASTExtraBaseCharacter_IsSameTeam_Params params;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameCamp
// (Native, Public)
// Parameters:
// class APawn*                   Other                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsSameCamp(class APawn* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsSameCamp");

	ASTExtraBaseCharacter_IsSameCamp_Params params;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsProneMove
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsProneMove()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsProneMove");

	ASTExtraBaseCharacter_IsProneMove_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsPlayer
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsPlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsPlayer");

	ASTExtraBaseCharacter_IsPlayer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsOnVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsOnVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsOnVehicle");

	ASTExtraBaseCharacter_IsOnVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsNearDeath
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsNearDeath()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsNearDeath");

	ASTExtraBaseCharacter_IsNearDeath_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsMutexSkillCoolDownFinished
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsMutexSkillCoolDownFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsMutexSkillCoolDownFinished");

	ASTExtraBaseCharacter_IsMutexSkillCoolDownFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsLocalViewed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsLocalViewed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsLocalViewed");

	ASTExtraBaseCharacter_IsLocalViewed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsInFlyingTeam
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsInFlyingTeam()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsInFlyingTeam");

	ASTExtraBaseCharacter_IsInFlyingTeam_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsInEditor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsInEditor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsInEditor");

	ASTExtraBaseCharacter_IsInEditor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsHealthyAlive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsHealthyAlive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsHealthyAlive");

	ASTExtraBaseCharacter_IsHealthyAlive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsHandleInFold
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsHandleInFold()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsHandleInFold");

	ASTExtraBaseCharacter_IsHandleInFold_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsFirstPerson
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsFirstPerson()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsFirstPerson");

	ASTExtraBaseCharacter_IsFirstPerson_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsExitingParachute
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsExitingParachute()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsExitingParachute");

	ASTExtraBaseCharacter_IsExitingParachute_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsDeathPlayViewTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsDeathPlayViewTarget()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsDeathPlayViewTarget");

	ASTExtraBaseCharacter_IsDeathPlayViewTarget_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsCharacterSprinting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsCharacterSprinting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsCharacterSprinting");

	ASTExtraBaseCharacter_IsCharacterSprinting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsAllowScopeIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsAllowScopeIn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsAllowScopeIn");

	ASTExtraBaseCharacter_IsAllowScopeIn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.IsAlive
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::IsAlive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.IsAlive");

	ASTExtraBaseCharacter_IsAlive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.InviteTeammate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FString>         Names                          (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::InviteTeammate(TArray<struct FString> Names)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.InviteTeammate");

	ASTExtraBaseCharacter_InviteTeammate_Params params;
	params.Names = Names;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.InsertDelayStateRelation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     OldState                       (Parm, ZeroConstructor, IsPlainOldData)
// EPawnState                     NewState                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::InsertDelayStateRelation(EPawnState OldState, EPawnState NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.InsertDelayStateRelation");

	ASTExtraBaseCharacter_InsertDelayStateRelation_Params params;
	params.OldState = OldState;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.InitBodyBoneMap
// (Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::InitBodyBoneMap()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.InitBodyBoneMap");

	ASTExtraBaseCharacter_InitBodyBoneMap_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HidePlayerMagOnGunReload
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::HidePlayerMagOnGunReload()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HidePlayerMagOnGunReload");

	ASTExtraBaseCharacter_HidePlayerMagOnGunReload_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HideNightVisionFrame
// (Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::HideNightVisionFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HideNightVisionFrame");

	ASTExtraBaseCharacter_HideNightVisionFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HasState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::HasState(EPawnState State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HasState");

	ASTExtraBaseCharacter_HasState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandleWeaponOnShoot
// (Final, Native, Public)

void ASTExtraBaseCharacter::HandleWeaponOnShoot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandleWeaponOnShoot");

	ASTExtraBaseCharacter_HandleWeaponOnShoot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayOperateItemSoundOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 BankName                       (Parm, ZeroConstructor)
// struct FString                 SoundName                      (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::HandlePlayOperateItemSoundOnServer(const struct FString& BankName, const struct FString& SoundName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayOperateItemSoundOnServer");

	ASTExtraBaseCharacter_HandlePlayOperateItemSoundOnServer_Params params;
	params.BankName = BankName;
	params.SoundName = SoundName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayerPoseChanged
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastPose                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     NewPose                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::HandlePlayerPoseChanged(TEnumAsByte<ESTEPoseState> LastPose, TEnumAsByte<ESTEPoseState> NewPose)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayerPoseChanged");

	ASTExtraBaseCharacter_HandlePlayerPoseChanged_Params params;
	params.LastPose = LastPose;
	params.NewPose = NewPose;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayerPickUpActor
// (Final, Native, Public)
// Parameters:
// class AActor*                  WrapperActor                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          TargetZLoc                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::HandlePlayerPickUpActor(class AActor* WrapperActor, float TargetZLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandlePlayerPickUpActor");

	ASTExtraBaseCharacter_HandlePlayerPickUpActor_Params params;
	params.WrapperActor = WrapperActor;
	params.TargetZLoc = TargetZLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandleOpenPickUpBoxAction
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::HandleOpenPickUpBoxAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandleOpenPickUpBoxAction");

	ASTExtraBaseCharacter_HandleOpenPickUpBoxAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandleOnCharAnimLoadingFinished
// (Final, Native, Public)

void ASTExtraBaseCharacter::HandleOnCharAnimLoadingFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandleOnCharAnimLoadingFinished");

	ASTExtraBaseCharacter_HandleOnCharAnimLoadingFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandleConsumeItemSkillBreak
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::HandleConsumeItemSkillBreak()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandleConsumeItemSkillBreak");

	ASTExtraBaseCharacter_HandleConsumeItemSkillBreak_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.HandleAutoSwitchWeaponDelay
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::HandleAutoSwitchWeaponDelay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.HandleAutoSwitchWeaponDelay");

	ASTExtraBaseCharacter_HandleAutoSwitchWeaponDelay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GrenadeBackToWeaponServerCall
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable, NetValidate)

void ASTExtraBaseCharacter::GrenadeBackToWeaponServerCall()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GrenadeBackToWeaponServerCall");

	ASTExtraBaseCharacter_GrenadeBackToWeaponServerCall_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GMTestZengzuo
// (Final, Exec, Native, Public)

void ASTExtraBaseCharacter::GMTestZengzuo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GMTestZengzuo");

	ASTExtraBaseCharacter_GMTestZengzuo_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GMShowName
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::GMShowName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GMShowName");

	ASTExtraBaseCharacter_GMShowName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetWeaponManager
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWeaponManagerComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UWeaponManagerComponent* ASTExtraBaseCharacter::GetWeaponManager()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetWeaponManager");

	ASTExtraBaseCharacter_GetWeaponManager_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetViewRotation
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator ASTExtraBaseCharacter::GetViewRotation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetViewRotation");

	ASTExtraBaseCharacter_GetViewRotation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetValueLimitForHealthPredict
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraBaseCharacter::GetValueLimitForHealthPredict()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetValueLimitForHealthPredict");

	ASTExtraBaseCharacter_GetValueLimitForHealthPredict_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetThrowGrenadeMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EThrowGrenadeMode> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EThrowGrenadeMode> ASTExtraBaseCharacter::GetThrowGrenadeMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetThrowGrenadeMode");

	ASTExtraBaseCharacter_GetThrowGrenadeMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetTeamMateIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Teammate                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraBaseCharacter::GetTeamMateIndex(class ASTExtraBaseCharacter* Teammate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetTeamMateIndex");

	ASTExtraBaseCharacter_GetTeamMateIndex_Params params;
	params.Teammate = Teammate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetShootWeaponNameByWeapon
// (Event, Protected, BlueprintEvent)
// Parameters:
// int                            ItemDefineID                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraBaseCharacter::GetShootWeaponNameByWeapon(int ItemDefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetShootWeaponNameByWeapon");

	ASTExtraBaseCharacter_GetShootWeaponNameByWeapon_Params params;
	params.ItemDefineID = ItemDefineID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetRandomPutDownLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                          OverrideFindPutDownPointZThreshold (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraBaseCharacter::GetRandomPutDownLocation(float OverrideFindPutDownPointZThreshold)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetRandomPutDownLocation");

	ASTExtraBaseCharacter_GetRandomPutDownLocation_Params params;
	params.OverrideFindPutDownPointZThreshold = OverrideFindPutDownPointZThreshold;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerWeaponFireMode
// (Final, Native, Public, Const)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESTEWeaponShootType> ASTExtraBaseCharacter::GetPlayerWeaponFireMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerWeaponFireMode");

	ASTExtraBaseCharacter_GetPlayerWeaponFireMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerWeaponEquipSlot
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ESurviveWeaponPropSlot> ASTExtraBaseCharacter::GetPlayerWeaponEquipSlot()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerWeaponEquipSlot");

	ASTExtraBaseCharacter_GetPlayerWeaponEquipSlot_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerVehAnimParam
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FAnimVehParamList       ReturnValue                    (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm)

struct FAnimVehParamList ASTExtraBaseCharacter::GetPlayerVehAnimParam(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerVehAnimParam");

	ASTExtraBaseCharacter_GetPlayerVehAnimParam_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerVehAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FPlayerVehAnimList      ReturnValue                    (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm)

struct FPlayerVehAnimList ASTExtraBaseCharacter::GetPlayerVehAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerVehAnimation");

	ASTExtraBaseCharacter_GetPlayerVehAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerTeamIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraBaseCharacter::GetPlayerTeamIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerTeamIndex");

	ASTExtraBaseCharacter_GetPlayerTeamIndex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerStateSafety
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerState*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerState* ASTExtraBaseCharacter::GetPlayerStateSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerStateSafety");

	ASTExtraBaseCharacter_GetPlayerStateSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerJumpType
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ECharacterJumpType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ECharacterJumpType> ASTExtraBaseCharacter::GetPlayerJumpType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerJumpType");

	ASTExtraBaseCharacter_GetPlayerJumpType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerControllerSafety
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* ASTExtraBaseCharacter::GetPlayerControllerSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerControllerSafety");

	ASTExtraBaseCharacter_GetPlayerControllerSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerControllerInReplay
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* ASTExtraBaseCharacter::GetPlayerControllerInReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerControllerInReplay");

	ASTExtraBaseCharacter_GetPlayerControllerInReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimParam
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FAnimParamList          ReturnValue                    (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm)

struct FAnimParamList ASTExtraBaseCharacter::GetPlayerAnimParam(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimParam");

	ASTExtraBaseCharacter_GetPlayerAnimParam_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimationByEventType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ECharAnimEventType> AnimEventType                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FPlayerAnimData         ReturnValue                    (Parm, OutParm, ReturnParm)

struct FPlayerAnimData ASTExtraBaseCharacter::GetPlayerAnimationByEventType(TEnumAsByte<ECharAnimEventType> AnimEventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimationByEventType");

	ASTExtraBaseCharacter_GetPlayerAnimationByEventType_Params params;
	params.AnimEventType = AnimEventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FPlayerAnimList         ReturnValue                    (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm)

struct FPlayerAnimList ASTExtraBaseCharacter::GetPlayerAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetPlayerAnimation");

	ASTExtraBaseCharacter_GetPlayerAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetLatestInviter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraBaseCharacter::GetLatestInviter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetLatestInviter");

	ASTExtraBaseCharacter_GetLatestInviter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetIsPlayingEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::GetIsPlayingEmote()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetIsPlayingEmote");

	ASTExtraBaseCharacter_GetIsPlayingEmote_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetIsFPP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::GetIsFPP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetIsFPP");

	ASTExtraBaseCharacter_GetIsFPP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBoxByState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     InPoseState                    (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UPrimitiveComponent* ASTExtraBaseCharacter::GetHitBoxByState(EPawnState InPoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBoxByState");

	ASTExtraBaseCharacter_GetHitBoxByState_Params params;
	params.InPoseState = InPoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyTypeByHitPos
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InHitPos                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// EAvatarDamagePosition          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EAvatarDamagePosition ASTExtraBaseCharacter::GetHitBodyTypeByHitPos(const struct FVector& InHitPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyTypeByHitPos");

	ASTExtraBaseCharacter_GetHitBodyTypeByHitPos_Params params;
	params.InHitPos = InHitPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyTypeByBoneName
// (Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 InBoneName                     (Parm, ZeroConstructor)
// EAvatarDamagePosition          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EAvatarDamagePosition ASTExtraBaseCharacter::GetHitBodyTypeByBoneName(const struct FString& InBoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyTypeByBoneName");

	ASTExtraBaseCharacter_GetHitBodyTypeByBoneName_Params params;
	params.InBoneName = InBoneName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyType
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InHitPos                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FString                 InBoneName                     (Parm, ZeroConstructor)
// EAvatarDamagePosition          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EAvatarDamagePosition ASTExtraBaseCharacter::GetHitBodyType(const struct FVector& InHitPos, const struct FString& InBoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetHitBodyType");

	ASTExtraBaseCharacter_GetHitBodyType_Params params;
	params.InHitPos = InHitPos;
	params.InBoneName = InBoneName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetHeadLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// bool                           bUseHeadBone                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraBaseCharacter::GetHeadLocation(bool bUseHeadBone)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetHeadLocation");

	ASTExtraBaseCharacter_GetHeadLocation_Params params;
	params.bUseHeadBone = bUseHeadBone;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetGrenadeNameByGrenadeType
// (Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<EGrenadeType>      grenadeType                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraBaseCharacter::GetGrenadeNameByGrenadeType(TEnumAsByte<EGrenadeType> grenadeType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetGrenadeNameByGrenadeType");

	ASTExtraBaseCharacter_GetGrenadeNameByGrenadeType_Params params;
	params.grenadeType = grenadeType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetFPPComp
// (Final, Native, Public)
// Parameters:
// class UBaseFPPComponent*       ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBaseFPPComponent* ASTExtraBaseCharacter::GetFPPComp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetFPPComp");

	ASTExtraBaseCharacter_GetFPPComp_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetFollowerLocOffset
// (Final, Native, Public, HasDefaults)
// Parameters:
// class ASTExtraBaseCharacter*   follower                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraBaseCharacter::GetFollowerLocOffset(class ASTExtraBaseCharacter* follower)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetFollowerLocOffset");

	ASTExtraBaseCharacter_GetFollowerLocOffset_Params params;
	params.follower = follower;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetFollowerLoc
// (Final, Native, Public, HasDefaults)
// Parameters:
// class ASTExtraBaseCharacter*   follower                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraBaseCharacter::GetFollowerLoc(class ASTExtraBaseCharacter* follower)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetFollowerLoc");

	ASTExtraBaseCharacter_GetFollowerLoc_Params params;
	params.follower = follower;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetEmoteHandle
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackEmoteHandle*    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBackpackEmoteHandle* ASTExtraBaseCharacter::GetEmoteHandle(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetEmoteHandle");

	ASTExtraBaseCharacter_GetEmoteHandle_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetEmote
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            ItemDefineID                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraBaseCharacter::GetEmote(int ItemDefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetEmote");

	ASTExtraBaseCharacter_GetEmote_Params params;
	params.ItemDefineID = ItemDefineID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraBaseCharacter::GetCurrentWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentWeapon");

	ASTExtraBaseCharacter_GetCurrentWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentVehicle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraVehicleBase*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraVehicleBase* ASTExtraBaseCharacter::GetCurrentVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentVehicle");

	ASTExtraBaseCharacter_GetCurrentVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentShootWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraShootWeapon*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraShootWeapon* ASTExtraBaseCharacter::GetCurrentShootWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentShootWeapon");

	ASTExtraBaseCharacter_GetCurrentShootWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentShieldWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraBaseCharacter::GetCurrentShieldWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurrentShieldWeapon");

	ASTExtraBaseCharacter_GetCurrentShieldWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurHitPartJugementType
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EHitPartJugementType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EHitPartJugementType> ASTExtraBaseCharacter::GetCurHitPartJugementType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCurHitPartJugementType");

	ASTExtraBaseCharacter_GetCurHitPartJugementType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCorpName
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString ASTExtraBaseCharacter::GetCorpName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCorpName");

	ASTExtraBaseCharacter_GetCorpName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetControllerSafety
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* ASTExtraBaseCharacter::GetControllerSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetControllerSafety");

	ASTExtraBaseCharacter_GetControllerSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCharacterXYPlaneVelocity
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraBaseCharacter::GetCharacterXYPlaneVelocity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCharacterXYPlaneVelocity");

	ASTExtraBaseCharacter_GetCharacterXYPlaneVelocity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCharacterEnergy
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FCharacterEnergyData    ReturnValue                    (Parm, OutParm, ReturnParm)

struct FCharacterEnergyData ASTExtraBaseCharacter::GetCharacterEnergy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCharacterEnergy");

	ASTExtraBaseCharacter_GetCharacterEnergy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetCachedControlRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator ASTExtraBaseCharacter::GetCachedControlRotation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetCachedControlRotation");

	ASTExtraBaseCharacter_GetCachedControlRotation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.GetActiveSpringArm
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraBaseCharacter::GetActiveSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.GetActiveSpringArm");

	ASTExtraBaseCharacter_GetActiveSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ForcePlayerUpdateAnimation
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::ForcePlayerUpdateAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ForcePlayerUpdateAnimation");

	ASTExtraBaseCharacter_ForcePlayerUpdateAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ForceDestroyWeaponInventoryAndClearData
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::ForceDestroyWeaponInventoryAndClearData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ForceDestroyWeaponInventoryAndClearData");

	ASTExtraBaseCharacter_ForceDestroyWeaponInventoryAndClearData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ForceCorrectClient
// (Net, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 Postion                        (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FRotator                Rotation                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 Velocity                       (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::ForceCorrectClient(const struct FVector& Postion, const struct FRotator& Rotation, const struct FVector& Velocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ForceCorrectClient");

	ASTExtraBaseCharacter_ForceCorrectClient_Params params;
	params.Postion = Postion;
	params.Rotation = Rotation;
	params.Velocity = Velocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.FollowTeammate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 Name                           (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::FollowTeammate(const struct FString& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.FollowTeammate");

	ASTExtraBaseCharacter_FollowTeammate_Params params;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.FindBuffRelatedPawnState
// (Final, Native, Public)
// Parameters:
// struct FName                   _buffName                      (Parm, ZeroConstructor, IsPlainOldData)
// EPawnState                     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EPawnState ASTExtraBaseCharacter::FindBuffRelatedPawnState(const struct FName& _buffName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.FindBuffRelatedPawnState");

	ASTExtraBaseCharacter_FindBuffRelatedPawnState_Params params;
	params._buffName = _buffName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.FillPlayerAnimRate
// (Final, Native, Public, HasOutParms, Const)
// Parameters:
// struct FPlayerAnimList         InAnimList                     (Parm, OutParm)

void ASTExtraBaseCharacter::FillPlayerAnimRate(struct FPlayerAnimList* InAnimList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.FillPlayerAnimRate");

	ASTExtraBaseCharacter_FillPlayerAnimRate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (InAnimList != nullptr)
		*InAnimList = params.InAnimList;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ExecFollowTeammate
// (Final, Exec, Native, Public)
// Parameters:
// struct FString                 Name                           (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::ExecFollowTeammate(const struct FString& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ExecFollowTeammate");

	ASTExtraBaseCharacter_ExecFollowTeammate_Params params;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EquipZoomScope
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            WeaponID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            ScopeID                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::EquipZoomScope(int WeaponID, int ScopeID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EquipZoomScope");

	ASTExtraBaseCharacter_EquipZoomScope_Params params;
	params.WeaponID = WeaponID;
	params.ScopeID = ScopeID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EquipWeaponFinish
// (Final, Native, Public)

void ASTExtraBaseCharacter::EquipWeaponFinish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EquipWeaponFinish");

	ASTExtraBaseCharacter_EquipWeaponFinish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EquipWeapon
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bSwitchWeapon                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::EquipWeapon(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bSwitchWeapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EquipWeapon");

	ASTExtraBaseCharacter_EquipWeapon_Params params;
	params.Slot = Slot;
	params.bSwitchWeapon = bSwitchWeapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EnterState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::EnterState(EPawnState State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EnterState");

	ASTExtraBaseCharacter_EnterState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EnterServerState
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::EnterServerState(EPawnState State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EnterServerState");

	ASTExtraBaseCharacter_EnterServerState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EnableCurrentWeaponInfiniteBullets
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::EnableCurrentWeaponInfiniteBullets(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EnableCurrentWeaponInfiniteBullets");

	ASTExtraBaseCharacter_EnableCurrentWeaponInfiniteBullets_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.EmoteAnimFinishedSuccessfully
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::EmoteAnimFinishedSuccessfully()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.EmoteAnimFinishedSuccessfully");

	ASTExtraBaseCharacter_EmoteAnimFinishedSuccessfully_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DisappearOnDeath
// (Final, Native, Private)

void ASTExtraBaseCharacter::DisappearOnDeath()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DisappearOnDeath");

	ASTExtraBaseCharacter_DisappearOnDeath_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DettachWeapon
// (Final, Native, Public)

void ASTExtraBaseCharacter::DettachWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DettachWeapon");

	ASTExtraBaseCharacter_DettachWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyWeaponOnServerByPropSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bEnableBroadcast               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::DestroyWeaponOnServerByPropSlot(TEnumAsByte<ESurviveWeaponPropSlot> Slot, bool bEnableBroadcast)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyWeaponOnServerByPropSlot");

	ASTExtraBaseCharacter_DestroyWeaponOnServerByPropSlot_Params params;
	params.Slot = Slot;
	params.bEnableBroadcast = bEnableBroadcast;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyWeaponOnServer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FName                   LogicSocket                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bEnableBroadcast               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::DestroyWeaponOnServer(const struct FName& LogicSocket, bool bEnableBroadcast)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyWeaponOnServer");

	ASTExtraBaseCharacter_DestroyWeaponOnServer_Params params;
	params.LogicSocket = LogicSocket;
	params.bEnableBroadcast = bEnableBroadcast;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyGrenadeAndSwitchBackToPreviousWeaponOnServer
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::DestroyGrenadeAndSwitchBackToPreviousWeaponOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DestroyGrenadeAndSwitchBackToPreviousWeaponOnServer");

	ASTExtraBaseCharacter_DestroyGrenadeAndSwitchBackToPreviousWeaponOnServer_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DelayMoveEnd
// (Final, Native, Protected)

void ASTExtraBaseCharacter::DelayMoveEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DelayMoveEnd");

	ASTExtraBaseCharacter_DelayMoveEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DelayMove
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::DelayMove(float Time)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DelayMove");

	ASTExtraBaseCharacter_DelayMove_Params params;
	params.Time = Time;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.DelayCustomDepth
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::DelayCustomDepth(float Time)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.DelayCustomDepth");

	ASTExtraBaseCharacter_DelayCustomDepth_Params params;
	params.Time = Time;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertWeaponSlotToCharacterAnimType
// (Final, Native, Public, Const)
// Parameters:
// TEnumAsByte<ESurviveWeaponPropSlot> WeaponSlot                     (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterAnimType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ECharacterAnimType> ASTExtraBaseCharacter::ConvertWeaponSlotToCharacterAnimType(TEnumAsByte<ESurviveWeaponPropSlot> WeaponSlot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertWeaponSlotToCharacterAnimType");

	ASTExtraBaseCharacter_ConvertWeaponSlotToCharacterAnimType_Params params;
	params.WeaponSlot = WeaponSlot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertWeaponFireModeToWeaponAnimType
// (Final, Native, Public, Const)
// Parameters:
// TEnumAsByte<ESTEWeaponShootType> FireMode                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterAnimType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ECharacterAnimType> ASTExtraBaseCharacter::ConvertWeaponFireModeToWeaponAnimType(TEnumAsByte<ESTEWeaponShootType> FireMode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertWeaponFireModeToWeaponAnimType");

	ASTExtraBaseCharacter_ConvertWeaponFireModeToWeaponAnimType_Params params;
	params.FireMode = FireMode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertCharacterPoseStateToPoseType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ESTEPoseState>     InPoseState                    (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterPoseType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ECharacterPoseType> ASTExtraBaseCharacter::ConvertCharacterPoseStateToPoseType(TEnumAsByte<ESTEPoseState> InPoseState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ConvertCharacterPoseStateToPoseType");

	ASTExtraBaseCharacter_ConvertCharacterPoseStateToPoseType_Params params;
	params.InPoseState = InPoseState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CloseWorldPawnCollision
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::CloseWorldPawnCollision()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CloseWorldPawnCollision");

	ASTExtraBaseCharacter_CloseWorldPawnCollision_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSyncServerTagsChange
// (Net, NetReliable, Native, Event, Public, NetClient, NetValidate)
// Parameters:
// TArray<struct FName>           newTags                        (ConstParm, Parm, ZeroConstructor, ReferenceParm)
// TArray<struct FName>           oldTags                        (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::ClientSyncServerTagsChange(TArray<struct FName> newTags, TArray<struct FName> oldTags)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSyncServerTagsChange");

	ASTExtraBaseCharacter_ClientSyncServerTagsChange_Params params;
	params.newTags = newTags;
	params.oldTags = oldTags;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSomeOneResponseMe
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FString                 BeInvitedName                  (Parm, ZeroConstructor)
// EInviteResponceType            res                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ClientSomeOneResponseMe(const struct FString& BeInvitedName, EInviteResponceType res)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSomeOneResponseMe");

	ASTExtraBaseCharacter_ClientSomeOneResponseMe_Params params;
	params.BeInvitedName = BeInvitedName;
	params.res = res;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSomeOneInviteMe
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// struct FString                 SomeOne                        (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::ClientSomeOneInviteMe(const struct FString& SomeOne)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSomeOneInviteMe");

	ASTExtraBaseCharacter_ClientSomeOneInviteMe_Params params;
	params.SomeOne = SomeOne;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSetLeaveVehicleLocation
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FVector                 LeaveLocation                  (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::ClientSetLeaveVehicleLocation(const struct FVector& LeaveLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientSetLeaveVehicleLocation");

	ASTExtraBaseCharacter_ClientSetLeaveVehicleLocation_Params params;
	params.LeaveLocation = LeaveLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientResponseFeedback
// (Net, Native, Event, Public, NetClient)
// Parameters:
// EInviteResponceType            res                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ClientResponseFeedback(EInviteResponceType res)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientResponseFeedback");

	ASTExtraBaseCharacter_ClientResponseFeedback_Params params;
	params.res = res;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientOnPossessBy
// (Net, NetReliable, Native, Event, Protected, NetClient, NetValidate)
// Parameters:
// class AController*             NewController                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ClientOnPossessBy(class AController* NewController)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientOnPossessBy");

	ASTExtraBaseCharacter_ClientOnPossessBy_Params params;
	params.NewController = NewController;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientHealthMaxChanged
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<struct FAttrAffected>   AffectedAttrS                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::ClientHealthMaxChanged(TArray<struct FAttrAffected> AffectedAttrS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientHealthMaxChanged");

	ASTExtraBaseCharacter_ClientHealthMaxChanged_Params params;
	params.AffectedAttrS = AffectedAttrS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClientBulletLineTrace
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient, NetValidate)
// Parameters:
// struct FVector                 BornPos                        (Parm, IsPlainOldData)
// struct FVector                 EndPos                         (Parm, IsPlainOldData)
// class ASTExtraBaseCharacter*   InstigatorCharacter            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ClientBulletLineTrace(const struct FVector& BornPos, const struct FVector& EndPos, class ASTExtraBaseCharacter* InstigatorCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClientBulletLineTrace");

	ASTExtraBaseCharacter_ClientBulletLineTrace_Params params;
	params.BornPos = BornPos;
	params.EndPos = EndPos;
	params.InstigatorCharacter = InstigatorCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugString
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InLocation                     (Parm, IsPlainOldData)
// struct FString                 InText                         (Parm, ZeroConstructor)
// class AActor*                  InActor                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Client_ShowDebugString(const struct FVector& InLocation, const struct FString& InText, class AActor* InActor, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugString");

	ASTExtraBaseCharacter_Client_ShowDebugString_Params params;
	params.InLocation = InLocation;
	params.InText = InText;
	params.InActor = InActor;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugSphere
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InLocation                     (Parm, IsPlainOldData)
// float                          InRadius                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Client_ShowDebugSphere(const struct FVector& InLocation, float InRadius, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugSphere");

	ASTExtraBaseCharacter_Client_ShowDebugSphere_Params params;
	params.InLocation = InLocation;
	params.InRadius = InRadius;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugLine
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InStart                        (Parm, IsPlainOldData)
// struct FVector                 InEnd                          (Parm, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Client_ShowDebugLine(const struct FVector& InStart, const struct FVector& InEnd, const struct FColor& InColor, float InTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugLine");

	ASTExtraBaseCharacter_Client_ShowDebugLine_Params params;
	params.InStart = InStart;
	params.InEnd = InEnd;
	params.InColor = InColor;
	params.InTime = InTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugCone
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 InLocation                     (Parm, IsPlainOldData)
// float                          InRadius                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 forwardDir                     (Parm, IsPlainOldData)
// float                          ang                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::Client_ShowDebugCone(const struct FVector& InLocation, float InRadius, const struct FColor& InColor, float InTime, const struct FVector& forwardDir, float ang)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugCone");

	ASTExtraBaseCharacter_Client_ShowDebugCone_Params params;
	params.InLocation = InLocation;
	params.InRadius = InRadius;
	params.InColor = InColor;
	params.InTime = InTime;
	params.forwardDir = forwardDir;
	params.ang = ang;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugBox
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Center                         (Parm, IsPlainOldData)
// struct FColor                  InColor                        (Parm, IsPlainOldData)
// float                          InTime                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Extent                         (Parm, IsPlainOldData)
// struct FQuat                   Rot                            (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::Client_ShowDebugBox(const struct FVector& Center, const struct FColor& InColor, float InTime, const struct FVector& Extent, const struct FQuat& Rot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.Client_ShowDebugBox");

	ASTExtraBaseCharacter_Client_ShowDebugBox_Params params;
	params.Center = Center;
	params.InColor = InColor;
	params.InTime = InTime;
	params.Extent = Extent;
	params.Rot = Rot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClearOnDeath
// (Final, Native, Protected)
// Parameters:
// class AController*             EventInstigater                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::ClearOnDeath(class AController* EventInstigater)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClearOnDeath");

	ASTExtraBaseCharacter_ClearOnDeath_Params params;
	params.EventInstigater = EventInstigater;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClearHPUI
// (Native, Public)

void ASTExtraBaseCharacter::ClearHPUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClearHPUI");

	ASTExtraBaseCharacter_ClearHPUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.ClearClientJump
// (Final, Native, Public)

void ASTExtraBaseCharacter::ClearClientJump()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.ClearClientJump");

	ASTExtraBaseCharacter_ClearClientJump_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CheckPlayerNeedUpdateAnimation
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// unsigned char                  OutForceUpdateFlag             (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::CheckPlayerNeedUpdateAnimation(unsigned char* OutForceUpdateFlag)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CheckPlayerNeedUpdateAnimation");

	ASTExtraBaseCharacter_CheckPlayerNeedUpdateAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutForceUpdateFlag != nullptr)
		*OutForceUpdateFlag = params.OutForceUpdateFlag;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CharacterMovementUpdatedCallback
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 OldLocation                    (Parm, IsPlainOldData)
// struct FVector                 OldVelocity                    (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::CharacterMovementUpdatedCallback(float DeltaTime, const struct FVector& OldLocation, const struct FVector& OldVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CharacterMovementUpdatedCallback");

	ASTExtraBaseCharacter_CharacterMovementUpdatedCallback_Params params;
	params.DeltaTime = DeltaTime;
	params.OldLocation = OldLocation;
	params.OldVelocity = OldVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CanStartReceive
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::CanStartReceive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CanStartReceive");

	ASTExtraBaseCharacter_CanStartReceive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CanEnterState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     NewState                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::CanEnterState(EPawnState NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CanEnterState");

	ASTExtraBaseCharacter_CanEnterState_Params params;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CanChangeThrowMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::CanChangeThrowMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CanChangeThrowMode");

	ASTExtraBaseCharacter_CanChangeThrowMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.CancelFollow
// (Final, Native, Public, BlueprintCallable)

void ASTExtraBaseCharacter::CancelFollow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.CancelFollow");

	ASTExtraBaseCharacter_CancelFollow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BulletLineTrace
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 BornPos                        (Parm, IsPlainOldData)
// struct FVector                 EndPos                         (Parm, IsPlainOldData)
// class UPrimitiveComponent*     meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  BulletActor                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BulletLineTrace(const struct FVector& BornPos, const struct FVector& EndPos, class UPrimitiveComponent* meshComp, class AActor* BulletActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BulletLineTrace");

	ASTExtraBaseCharacter_BulletLineTrace_Params params;
	params.BornPos = BornPos;
	params.EndPos = EndPos;
	params.meshComp = meshComp;
	params.BulletActor = BulletActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BulletChange
// (Net, NetReliable, Native, Event, NetMulticast, Public, NetValidate)

void ASTExtraBaseCharacter::BulletChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BulletChange");

	ASTExtraBaseCharacter_BulletChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastOtherClientsDie
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults, NetValidate)
// Parameters:
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, ReferenceParm)
// bool                           bIsPointDamage                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastOtherClientsDie(class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, const struct FDamageEvent& DamageEvent, bool bIsPointDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastOtherClientsDie");

	ASTExtraBaseCharacter_BroadcastOtherClientsDie_Params params;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.DamageEvent = DamageEvent;
	params.bIsPointDamage = bIsPointDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastFatalDamageInfoWrapper
// (Final, Native, Public)
// Parameters:
// class AUAECharacter*           causer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AUAECharacter*           victimName                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadshot                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            ResultHealthStatus             (Parm, ZeroConstructor, IsPlainOldData)
// int                            PreviousHealthStatus           (Parm, ZeroConstructor, IsPlainOldData)
// class AUAECharacter*           WhoKillMe                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            KillerKillCount                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastFatalDamageInfoWrapper(class AUAECharacter* causer, class AUAECharacter* victimName, int DamageType, int AdditionalParam, bool IsHeadshot, int ResultHealthStatus, int PreviousHealthStatus, class AUAECharacter* WhoKillMe, int KillerKillCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastFatalDamageInfoWrapper");

	ASTExtraBaseCharacter_BroadcastFatalDamageInfoWrapper_Params params;
	params.causer = causer;
	params.victimName = victimName;
	params.DamageType = DamageType;
	params.AdditionalParam = AdditionalParam;
	params.IsHeadshot = IsHeadshot;
	params.ResultHealthStatus = ResultHealthStatus;
	params.PreviousHealthStatus = PreviousHealthStatus;
	params.WhoKillMe = WhoKillMe;
	params.KillerKillCount = KillerKillCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastFatalDamageInfo
// (Net, Native, Event, NetMulticast, Public)
// Parameters:
// class AUAECharacter*           causer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AUAECharacter*           Victim                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 causerName                     (Parm, ZeroConstructor)
// struct FString                 victimName                     (Parm, ZeroConstructor)
// int                            DamageType                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            AdditionalParam                (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamageWeaponSkin               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadshot                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            ResultHealthStatus             (Parm, ZeroConstructor, IsPlainOldData)
// int                            PreviousHealthStatus           (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 realKillerName                 (Parm, ZeroConstructor)
// int                            realKillerNewKillNum           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsCauserMonster                (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       causerKey                      (Parm, ZeroConstructor, IsPlainOldData)
// uint32_t                       victimKey                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            causerAnchorPlatformResID      (Parm, ZeroConstructor, IsPlainOldData)
// int                            causerAnchorPlatformColorID    (Parm, ZeroConstructor, IsPlainOldData)
// int                            victimAnchorPlatformResID      (Parm, ZeroConstructor, IsPlainOldData)
// int                            victimAnchorPlatformColorID    (Parm, ZeroConstructor, IsPlainOldData)
// int                            realKillerAnchorPlatformResID  (Parm, ZeroConstructor, IsPlainOldData)
// int                            realKillerAnchorPlatformColorID (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 CauseUID                       (Parm, ZeroConstructor)
// struct FString                 VictimUID                      (Parm, ZeroConstructor)

void ASTExtraBaseCharacter::BroadcastFatalDamageInfo(class AUAECharacter* causer, class AUAECharacter* Victim, const struct FString& causerName, const struct FString& victimName, int DamageType, int AdditionalParam, int DamageWeaponSkin, bool IsHeadshot, int ResultHealthStatus, int PreviousHealthStatus, const struct FString& realKillerName, int realKillerNewKillNum, bool IsCauserMonster, uint32_t causerKey, uint32_t victimKey, int causerAnchorPlatformResID, int causerAnchorPlatformColorID, int victimAnchorPlatformResID, int victimAnchorPlatformColorID, int realKillerAnchorPlatformResID, int realKillerAnchorPlatformColorID, const struct FString& CauseUID, const struct FString& VictimUID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastFatalDamageInfo");

	ASTExtraBaseCharacter_BroadcastFatalDamageInfo_Params params;
	params.causer = causer;
	params.Victim = Victim;
	params.causerName = causerName;
	params.victimName = victimName;
	params.DamageType = DamageType;
	params.AdditionalParam = AdditionalParam;
	params.DamageWeaponSkin = DamageWeaponSkin;
	params.IsHeadshot = IsHeadshot;
	params.ResultHealthStatus = ResultHealthStatus;
	params.PreviousHealthStatus = PreviousHealthStatus;
	params.realKillerName = realKillerName;
	params.realKillerNewKillNum = realKillerNewKillNum;
	params.IsCauserMonster = IsCauserMonster;
	params.causerKey = causerKey;
	params.victimKey = victimKey;
	params.causerAnchorPlatformResID = causerAnchorPlatformResID;
	params.causerAnchorPlatformColorID = causerAnchorPlatformColorID;
	params.victimAnchorPlatformResID = victimAnchorPlatformResID;
	params.victimAnchorPlatformColorID = victimAnchorPlatformColorID;
	params.realKillerAnchorPlatformResID = realKillerAnchorPlatformResID;
	params.realKillerAnchorPlatformColorID = realKillerAnchorPlatformColorID;
	params.CauseUID = CauseUID;
	params.VictimUID = VictimUID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateVehicleDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVehicleDamageEvent     VehicleDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateVehicleDamage(float BaseDamage, const struct FVehicleDamageEvent& VehicleDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateVehicleDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateVehicleDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.VehicleDamageEvent = VehicleDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateRadialDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FRadialDamageEvent      PointDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHeath                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateRadialDamage(float BaseDamage, const struct FRadialDamageEvent& PointDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHeath, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateRadialDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateRadialDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PointDamageEvent = PointDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHeath = ServerCurHeath;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulatePoisonDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FPoisonDamageEvent      PoisonDamageEvent              (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulatePoisonDamage(float BaseDamage, const struct FPoisonDamageEvent& PoisonDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulatePoisonDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulatePoisonDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PoisonDamageEvent = PoisonDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulatePointDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTPointDamageEvent     PointDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHeath                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulatePointDamage(float BaseDamage, const struct FSTPointDamageEvent& PointDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHeath, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulatePointDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulatePointDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PointDamageEvent = PointDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHeath = ServerCurHeath;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateMeleeDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FMeleeDamageEvent       MeleeDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateMeleeDamage(float BaseDamage, const struct FMeleeDamageEvent& MeleeDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateMeleeDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateMeleeDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.MeleeDamageEvent = MeleeDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateFallingDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FFallingDamageEvent     FallingDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateFallingDamage(float BaseDamage, const struct FFallingDamageEvent& FallingDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateFallingDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateFallingDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.FallingDamageEvent = FallingDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateDrowningDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FDrowningDamageEvent    DrowningDamageEvent            (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateDrowningDamage(float BaseDamage, const struct FDrowningDamageEvent& DrowningDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateDrowningDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateDrowningDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.DrowningDamageEvent = DrowningDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateBurningDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTBurningDamageEvent   BurningDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateBurningDamage(float BaseDamage, const struct FSTBurningDamageEvent& BurningDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateBurningDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateBurningDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.BurningDamageEvent = BurningDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateAirAttackDamage
// (Net, Native, Event, NetMulticast, Public, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTAirAttackRadialDamageEvent AirAttackDamageEvent           (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientsSimulateAirAttackDamage(float BaseDamage, const struct FSTAirAttackRadialDamageEvent& AirAttackDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientsSimulateAirAttackDamage");

	ASTExtraBaseCharacter_BroadcastClientsSimulateAirAttackDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.AirAttackDamageEvent = AirAttackDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientSimulateAnyDamage
// (Net, Native, Event, NetMulticast, Public)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIsFetalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIsHeadShotDamage              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BroadcastClientSimulateAnyDamage(float BaseDamage, const struct FDamageEvent& DamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool bIsFetalHealthCost, bool bIsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientSimulateAnyDamage");

	ASTExtraBaseCharacter_BroadcastClientSimulateAnyDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.DamageEvent = DamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params.bIsFetalHealthCost = bIsFetalHealthCost;
	params.bIsHeadShotDamage = bIsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientSimpleDamageCache
// (Net, Native, Event, NetMulticast, Public)
// Parameters:
// TArray<struct FSimpleDamageRepData> DamageData                     (ConstParm, Parm, ZeroConstructor, ReferenceParm)

void ASTExtraBaseCharacter::BroadcastClientSimpleDamageCache(TArray<struct FSimpleDamageRepData> DamageData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BroadcastClientSimpleDamageCache");

	ASTExtraBaseCharacter_BroadcastClientSimpleDamageCache_Params params;
	params.DamageData = DamageData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPTakeDamage
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             EventInstigator                (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraBaseCharacter::BPTakeDamage(float Damage, class AController* EventInstigator, class AActor* DamageCauser, const struct FDamageEvent& DamageEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPTakeDamage");

	ASTExtraBaseCharacter_BPTakeDamage_Params params;
	params.Damage = Damage;
	params.EventInstigator = EventInstigator;
	params.DamageCauser = DamageCauser;
	params.DamageEvent = DamageEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPResetCharacter
// (Event, Public, BlueprintEvent)

void ASTExtraBaseCharacter::BPResetCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPResetCharacter");

	ASTExtraBaseCharacter_BPResetCharacter_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveRadialDamage
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// float                          DamageReceived                 (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Origin                         (Parm, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitInfo                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ImpulseDir                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::BPReceiveRadialDamage(float DamageReceived, class UDamageType* DamageType, const struct FVector& Origin, float Radius, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser, const struct FVector& ImpulseDir)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveRadialDamage");

	ASTExtraBaseCharacter_BPReceiveRadialDamage_Params params;
	params.DamageReceived = DamageReceived;
	params.DamageType = DamageType;
	params.Origin = Origin;
	params.Radius = Radius;
	params.HitInfo = HitInfo;
	params.InstigatedBy = InstigatedBy;
	params.DamageCauser = DamageCauser;
	params.ImpulseDir = ImpulseDir;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceivePointDamage
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 HitLocation                    (Parm, IsPlainOldData)
// struct FVector                 HitNormal                      (Parm, IsPlainOldData)
// class UPrimitiveComponent*     HitComponent                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   BoneName                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ShotFromDirection              (Parm, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitInfo                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraBaseCharacter::BPReceivePointDamage(float Damage, class UDamageType* DamageType, const struct FVector& HitLocation, const struct FVector& HitNormal, class UPrimitiveComponent* HitComponent, const struct FName& BoneName, const struct FVector& ShotFromDirection, class AController* InstigatedBy, class AActor* DamageCauser, const struct FHitResult& HitInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceivePointDamage");

	ASTExtraBaseCharacter_BPReceivePointDamage_Params params;
	params.Damage = Damage;
	params.DamageType = DamageType;
	params.HitLocation = HitLocation;
	params.HitNormal = HitNormal;
	params.HitComponent = HitComponent;
	params.BoneName = BoneName;
	params.ShotFromDirection = ShotFromDirection;
	params.InstigatedBy = InstigatedBy;
	params.DamageCauser = DamageCauser;
	params.HitInfo = HitInfo;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveMeleeDamage
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BPReceiveMeleeDamage(float Damage, class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveMeleeDamage");

	ASTExtraBaseCharacter_BPReceiveMeleeDamage_Params params;
	params.Damage = Damage;
	params.DamageType = DamageType;
	params.InstigatedBy = InstigatedBy;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveDamage
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedBy                   (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BPReceiveDamage(float Damage, class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPReceiveDamage");

	ASTExtraBaseCharacter_BPReceiveDamage_Params params;
	params.Damage = Damage;
	params.DamageType = DamageType;
	params.InstigatedBy = InstigatedBy;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPNotifyStartDying
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  KillingHitDamageType           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BPNotifyStartDying(class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* KillingHitDamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPNotifyStartDying");

	ASTExtraBaseCharacter_BPNotifyStartDying_Params params;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.KillingHitDamageType = KillingHitDamageType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPNotifyDeathEnd
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  KillingHitDamageType           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::BPNotifyDeathEnd(class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* KillingHitDamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPNotifyDeathEnd");

	ASTExtraBaseCharacter_BPNotifyDeathEnd_Params params;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.KillingHitDamageType = KillingHitDamageType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.BPDie
// (Native, Event, Public, HasOutParms, BlueprintEvent)
// Parameters:
// float                          KillingDamage                  (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             EventInstigator                (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)

void ASTExtraBaseCharacter::BPDie(float KillingDamage, class AController* EventInstigator, class AActor* DamageCauser, const struct FDamageEvent& DamageEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.BPDie");

	ASTExtraBaseCharacter_BPDie_Params params;
	params.KillingDamage = KillingDamage;
	params.EventInstigator = EventInstigator;
	params.DamageCauser = DamageCauser;
	params.DamageEvent = DamageEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AutoScopeWhenPeek
// (Final, Native, Public)

void ASTExtraBaseCharacter::AutoScopeWhenPeek()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AutoScopeWhenPeek");

	ASTExtraBaseCharacter_AutoScopeWhenPeek_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AttachWeapon
// (Final, Native, Public)

void ASTExtraBaseCharacter::AttachWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AttachWeapon");

	ASTExtraBaseCharacter_AttachWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AsyncAnimOpenDoorCallback
// (Final, Native, Public)
// Parameters:
// class UAnimationAsset*         retAsset                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::AsyncAnimOpenDoorCallback(class UAnimationAsset* retAsset)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AsyncAnimOpenDoorCallback");

	ASTExtraBaseCharacter_AsyncAnimOpenDoorCallback_Params params;
	params.retAsset = retAsset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AllowState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EPawnState                     State                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           withLog                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraBaseCharacter::AllowState(EPawnState State, bool withLog)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AllowState");

	ASTExtraBaseCharacter_AllowState_Params params;
	params.State = State;
	params.withLog = withLog;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AIStartFireOnServer
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// int                            BurstShootBulletsLimit         (Parm, ZeroConstructor, IsPlainOldData)
// float                          BurstShootTimeLimit            (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EShootWeaponShootMode> ShootMode                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 SimpleShootTarget              (Parm, IsPlainOldData)

void ASTExtraBaseCharacter::AIStartFireOnServer(int BurstShootBulletsLimit, float BurstShootTimeLimit, TEnumAsByte<EShootWeaponShootMode> ShootMode, const struct FVector& SimpleShootTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AIStartFireOnServer");

	ASTExtraBaseCharacter_AIStartFireOnServer_Params params;
	params.BurstShootBulletsLimit = BurstShootBulletsLimit;
	params.BurstShootTimeLimit = BurstShootTimeLimit;
	params.ShootMode = ShootMode;
	params.SimpleShootTarget = SimpleShootTarget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AddOneDamageCauserRecord
// (Final, Native, Public, HasOutParms)
// Parameters:
// class AController*             causer                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            HSChangeMargin                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           IsHeadshot                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::AddOneDamageCauserRecord(class AController* causer, int HSChangeMargin, const struct FDamageEvent& DamageEvent, bool IsHeadshot, class AActor* DamageCauser)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AddOneDamageCauserRecord");

	ASTExtraBaseCharacter_AddOneDamageCauserRecord_Params params;
	params.causer = causer;
	params.HSChangeMargin = HSChangeMargin;
	params.DamageEvent = DamageEvent;
	params.IsHeadshot = IsHeadshot;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBaseCharacter.AddMoveOffSet
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Forward                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          Right                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Up                             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraBaseCharacter::AddMoveOffSet(float Forward, float Right, float Up)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBaseCharacter.AddMoveOffSet");

	ASTExtraBaseCharacter_AddMoveOffSet_Params params;
	params.Forward = Forward;
	params.Right = Right;
	params.Up = Up;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.Vector2Rotator
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 ver                            (Parm, IsPlainOldData)
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator USTExtraBlueprintFunctionLibrary::Vector2Rotator(const struct FVector& ver)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.Vector2Rotator");

	USTExtraBlueprintFunctionLibrary_Vector2Rotator_Params params;
	params.ver = ver;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.UpdateComponentOverlaps
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USceneComponent*         Comp                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::UpdateComponentOverlaps(class USceneComponent* Comp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.UpdateComponentOverlaps");

	USTExtraBlueprintFunctionLibrary_UpdateComponentOverlaps_Params params;
	params.Comp = Comp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.TraceGround
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 ContextObject                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 AboveGroundLoc                 (Parm, IsPlainOldData)
// float                          TraceDeepDis                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitInfo                        (Parm, OutParm, IsPlainOldData)
// bool                           bForceStatic                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::TraceGround(class UObject* ContextObject, const struct FVector& AboveGroundLoc, float TraceDeepDis, bool bForceStatic, struct FHitResult* HitInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.TraceGround");

	USTExtraBlueprintFunctionLibrary_TraceGround_Params params;
	params.ContextObject = ContextObject;
	params.AboveGroundLoc = AboveGroundLoc;
	params.TraceDeepDis = TraceDeepDis;
	params.bForceStatic = bForceStatic;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (HitInfo != nullptr)
		*HitInfo = params.HitInfo;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.TraceBlock
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 ContextObject                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Start                          (Parm, IsPlainOldData)
// struct FVector                 End                            (Parm, IsPlainOldData)
// struct FHitResult              HitInfo                        (Parm, OutParm, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool                           bForceStatic                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::TraceBlock(class UObject* ContextObject, const struct FVector& Start, const struct FVector& End, TArray<class AActor*> IgnoreActors, bool bForceStatic, struct FHitResult* HitInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.TraceBlock");

	USTExtraBlueprintFunctionLibrary_TraceBlock_Params params;
	params.ContextObject = ContextObject;
	params.Start = Start;
	params.End = End;
	params.IgnoreActors = IgnoreActors;
	params.bForceStatic = bForceStatic;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (HitInfo != nullptr)
		*HitInfo = params.HitInfo;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnCustomEmitterAttached
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UParticleSystem*         EmitterTemplate                (Parm, ZeroConstructor, IsPlainOldData)
// class USceneComponent*         AttachToComponent              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   AttachPointName                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Location                       (Parm, IsPlainOldData)
// struct FRotator                Rotation                       (Parm, IsPlainOldData)
// TEnumAsByte<EAttachLocation>   LocationType                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAutoDestroy                   (Parm, ZeroConstructor, IsPlainOldData)
// class UCustomParticleSystemComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCustomParticleSystemComponent* USTExtraBlueprintFunctionLibrary::SpawnCustomEmitterAttached(class UParticleSystem* EmitterTemplate, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, TEnumAsByte<EAttachLocation> LocationType, bool bAutoDestroy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnCustomEmitterAttached");

	USTExtraBlueprintFunctionLibrary_SpawnCustomEmitterAttached_Params params;
	params.EmitterTemplate = EmitterTemplate;
	params.AttachToComponent = AttachToComponent;
	params.AttachPointName = AttachPointName;
	params.Location = Location;
	params.Rotation = Rotation;
	params.LocationType = LocationType;
	params.bAutoDestroy = bAutoDestroy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnCustomEmitterAtLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class UParticleSystem*         EmitterTemplate                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Location                       (Parm, IsPlainOldData)
// struct FRotator                Rotation                       (Parm, IsPlainOldData)
// bool                           bAutoDestroy                   (Parm, ZeroConstructor, IsPlainOldData)
// class UCustomParticleSystemComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCustomParticleSystemComponent* USTExtraBlueprintFunctionLibrary::SpawnCustomEmitterAtLocation(class UObject* WorldContextObject, class UParticleSystem* EmitterTemplate, const struct FVector& Location, const struct FRotator& Rotation, bool bAutoDestroy)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnCustomEmitterAtLocation");

	USTExtraBlueprintFunctionLibrary_SpawnCustomEmitterAtLocation_Params params;
	params.WorldContextObject = WorldContextObject;
	params.EmitterTemplate = EmitterTemplate;
	params.Location = Location;
	params.Rotation = Rotation;
	params.bAutoDestroy = bAutoDestroy;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnActorFromString
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FString                 ActorPath                      (ConstParm, Parm, ZeroConstructor)
// struct FTransform              SpawnTransform                 (ConstParm, Parm, IsPlainOldData)
// class AActor*                  Owner                          (Parm, ZeroConstructor, IsPlainOldData)
// class APawn*                   Instigator                     (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* USTExtraBlueprintFunctionLibrary::SpawnActorFromString(const struct FString& ActorPath, const struct FTransform& SpawnTransform, class AActor* Owner, class APawn* Instigator)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SpawnActorFromString");

	USTExtraBlueprintFunctionLibrary_SpawnActorFromString_Params params;
	params.ActorPath = ActorPath;
	params.SpawnTransform = SpawnTransform;
	params.Owner = Owner;
	params.Instigator = Instigator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SortCorpsByKilledPlayer
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FGameModeCorpsDetailData> CorpsInfo                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<struct FGameModeCorpsDetailData> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FGameModeCorpsDetailData> USTExtraBlueprintFunctionLibrary::SortCorpsByKilledPlayer(TArray<struct FGameModeCorpsDetailData> CorpsInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SortCorpsByKilledPlayer");

	USTExtraBlueprintFunctionLibrary_SortCorpsByKilledPlayer_Params params;
	params.CorpsInfo = CorpsInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetUpPostProcessSetting
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class APostProcessVolume*      PostProcessVolume              (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UMaterialInstanceDynamic*> Blends                         (Parm, OutParm, ZeroConstructor, ReferenceParm)

void USTExtraBlueprintFunctionLibrary::SetUpPostProcessSetting(class APostProcessVolume* PostProcessVolume, TArray<class UMaterialInstanceDynamic*>* Blends)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetUpPostProcessSetting");

	USTExtraBlueprintFunctionLibrary_SetUpPostProcessSetting_Params params;
	params.PostProcessVolume = PostProcessVolume;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (Blends != nullptr)
		*Blends = params.Blends;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetPostProcessBlendEffectWeightByIndex
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APostProcessVolume*      PostProcessVolume              (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Index                          (Parm, ZeroConstructor, IsPlainOldData)
// float                          Weight                         (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::SetPostProcessBlendEffectWeightByIndex(class APostProcessVolume* PostProcessVolume, unsigned char Index, float Weight)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetPostProcessBlendEffectWeightByIndex");

	USTExtraBlueprintFunctionLibrary_SetPostProcessBlendEffectWeightByIndex_Params params;
	params.PostProcessVolume = PostProcessVolume;
	params.Index = Index;
	params.Weight = Weight;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetMeleeweaponMultiplier
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          Val                            (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::SetMeleeweaponMultiplier(class ASTExtraBaseCharacter* Character, float Val)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetMeleeweaponMultiplier");

	USTExtraBlueprintFunctionLibrary_SetMeleeweaponMultiplier_Params params;
	params.Character = Character;
	params.Val = Val;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetCollisionResponseForBodies
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*  SkelMesh                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TEnumAsByte<ECollisionChannel> Channel                        (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECollisionResponse> NewResponse                    (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FName>           BodyNames                      (Parm, ZeroConstructor)

void USTExtraBlueprintFunctionLibrary::SetCollisionResponseForBodies(class USkeletalMeshComponent* SkelMesh, TEnumAsByte<ECollisionChannel> Channel, TEnumAsByte<ECollisionResponse> NewResponse, TArray<struct FName> BodyNames)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.SetCollisionResponseForBodies");

	USTExtraBlueprintFunctionLibrary_SetCollisionResponseForBodies_Params params;
	params.SkelMesh = SkelMesh;
	params.Channel = Channel;
	params.NewResponse = NewResponse;
	params.BodyNames = BodyNames;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LoadCDOByPath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FString                 PathName                       (Parm, ZeroConstructor)
// class UObject*                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UObject* USTExtraBlueprintFunctionLibrary::LoadCDOByPath(const struct FString& PathName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LoadCDOByPath");

	USTExtraBlueprintFunctionLibrary_LoadCDOByPath_Params params;
	params.PathName = PathName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LimitVector
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 CurVec                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 MaxVec                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector USTExtraBlueprintFunctionLibrary::LimitVector(const struct FVector& CurVec, const struct FVector& MaxVec)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LimitVector");

	USTExtraBlueprintFunctionLibrary_LimitVector_Params params;
	params.CurVec = CurVec;
	params.MaxVec = MaxVec;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LimitRotator
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRotator                CurRot                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FRotator                MaxRot                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FRotator                ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FRotator USTExtraBlueprintFunctionLibrary::LimitRotator(const struct FRotator& CurRot, const struct FRotator& MaxRot)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.LimitRotator");

	USTExtraBlueprintFunctionLibrary_LimitRotator_Params params;
	params.CurRot = CurRot;
	params.MaxRot = MaxRot;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsTerminatorSelf
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::IsTerminatorSelf(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsTerminatorSelf");

	USTExtraBlueprintFunctionLibrary_IsTerminatorSelf_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsSamePlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AUAEPlayerState*         stateA                         (Parm, ZeroConstructor, IsPlainOldData)
// class AUAEPlayerState*         stateB                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::IsSamePlayerState(class AUAEPlayerState* stateA, class AUAEPlayerState* stateB)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsSamePlayerState");

	USTExtraBlueprintFunctionLibrary_IsSamePlayerState_Params params;
	params.stateA = stateA;
	params.stateB = stateB;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsPlayerCantBlock
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitResult                      (Parm, OutParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::IsPlayerCantBlock(class AActor* DamageCauser, struct FHitResult* HitResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsPlayerCantBlock");

	USTExtraBlueprintFunctionLibrary_IsPlayerCantBlock_Params params;
	params.DamageCauser = DamageCauser;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (HitResult != nullptr)
		*HitResult = params.HitResult;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsHiddenByOtherSlot
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// int                            itemResID                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::IsHiddenByOtherSlot(class ACharacter* Character, int itemResID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.IsHiddenByOtherSlot");

	USTExtraBlueprintFunctionLibrary_IsHiddenByOtherSlot_Params params;
	params.Character = Character;
	params.itemResID = itemResID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.HasTeammateAlive
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class ASTExtraPlayerState*     PS                             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::HasTeammateAlive(class ASTExtraPlayerState* PS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.HasTeammateAlive");

	USTExtraBlueprintFunctionLibrary_HasTeammateAlive_Params params;
	params.PS = PS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetWorldToUIShowLocationRect
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 WorldLocation                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector4                Limit                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector2D               UIOffset                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector2D               OutPosition                    (Parm, OutParm, IsPlainOldData)
// float                          angle                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::GetWorldToUIShowLocationRect(class UObject* WorldContextObject, const struct FVector& WorldLocation, const struct FVector4& Limit, const struct FVector2D& UIOffset, struct FVector2D* OutPosition, float* angle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetWorldToUIShowLocationRect");

	USTExtraBlueprintFunctionLibrary_GetWorldToUIShowLocationRect_Params params;
	params.WorldContextObject = WorldContextObject;
	params.WorldLocation = WorldLocation;
	params.Limit = Limit;
	params.UIOffset = UIOffset;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutPosition != nullptr)
		*OutPosition = params.OutPosition;
	if (angle != nullptr)
		*angle = params.angle;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetUIShowLocationAngle
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               InPosition                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector4                Limit                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraBlueprintFunctionLibrary::GetUIShowLocationAngle(class UObject* WorldContextObject, const struct FVector2D& InPosition, const struct FVector4& Limit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetUIShowLocationAngle");

	USTExtraBlueprintFunctionLibrary_GetUIShowLocationAngle_Params params;
	params.WorldContextObject = WorldContextObject;
	params.InPosition = InPosition;
	params.Limit = Limit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetSphereOverlappingActors
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          CollisionFreeRadius            (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Origin                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool                           DrawVisibleTraceDebugLine      (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class AActor*> USTExtraBlueprintFunctionLibrary::GetSphereOverlappingActors(class UObject* WorldContextObject, float Radius, float CollisionFreeRadius, const struct FVector& Origin, class AActor* DamageCauser, TArray<class AActor*> IgnoreActors, bool DrawVisibleTraceDebugLine)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetSphereOverlappingActors");

	USTExtraBlueprintFunctionLibrary_GetSphereOverlappingActors_Params params;
	params.WorldContextObject = WorldContextObject;
	params.Radius = Radius;
	params.CollisionFreeRadius = CollisionFreeRadius;
	params.Origin = Origin;
	params.DamageCauser = DamageCauser;
	params.IgnoreActors = IgnoreActors;
	params.DrawVisibleTraceDebugLine = DrawVisibleTraceDebugLine;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetRadialDamageImpulseAtLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 Location                       (Parm, IsPlainOldData)
// class UDamageType*             DamageType                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Origin                         (Parm, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraBlueprintFunctionLibrary::GetRadialDamageImpulseAtLocation(const struct FVector& Location, class UDamageType* DamageType, const struct FVector& Origin, float Radius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetRadialDamageImpulseAtLocation");

	USTExtraBlueprintFunctionLibrary_GetRadialDamageImpulseAtLocation_Params params;
	params.Location = Location;
	params.DamageType = DamageType;
	params.Origin = Origin;
	params.Radius = Radius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetPostProcessBlendEffectWeightByIndex
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APostProcessVolume*      PostProcessVolume              (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  Index                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FWeightedBlendable      ReturnValue                    (Parm, OutParm, ReturnParm)

struct FWeightedBlendable USTExtraBlueprintFunctionLibrary::GetPostProcessBlendEffectWeightByIndex(class APostProcessVolume* PostProcessVolume, unsigned char Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetPostProcessBlendEffectWeightByIndex");

	USTExtraBlueprintFunctionLibrary_GetPostProcessBlendEffectWeightByIndex_Params params;
	params.PostProcessVolume = PostProcessVolume;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetMaterialFromString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 Name                           (ConstParm, Parm, ZeroConstructor)
// class UMaterialInterface*      ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInterface* USTExtraBlueprintFunctionLibrary::GetMaterialFromString(const struct FString& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetMaterialFromString");

	USTExtraBlueprintFunctionLibrary_GetMaterialFromString_Params params;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetLockAndObsOptCompFromController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AController*             Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// class ULockAndObsOptComponent* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class ULockAndObsOptComponent* USTExtraBlueprintFunctionLibrary::GetLockAndObsOptCompFromController(class AController* Controller)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetLockAndObsOptCompFromController");

	USTExtraBlueprintFunctionLibrary_GetLockAndObsOptCompFromController_Params params;
	params.Controller = Controller;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetDeviceName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraBlueprintFunctionLibrary::GetDeviceName()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetDeviceName");

	USTExtraBlueprintFunctionLibrary_GetDeviceName_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetClassByPath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FString                 PathName                       (Parm, ZeroConstructor)
// class UClass*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UClass* USTExtraBlueprintFunctionLibrary::GetClassByPath(const struct FString& PathName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetClassByPath");

	USTExtraBlueprintFunctionLibrary_GetClassByPath_Params params;
	params.PathName = PathName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetChatComponentFromController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AController*             Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// class UChatComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UChatComponent* USTExtraBlueprintFunctionLibrary::GetChatComponentFromController(class AController* Controller)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetChatComponentFromController");

	USTExtraBlueprintFunctionLibrary_GetChatComponentFromController_Params params;
	params.Controller = Controller;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetChatComponentFromCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// class UChatComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UChatComponent* USTExtraBlueprintFunctionLibrary::GetChatComponentFromCharacter(class ACharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetChatComponentFromCharacter");

	USTExtraBlueprintFunctionLibrary_GetChatComponentFromCharacter_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetCakePlacer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* USTExtraBlueprintFunctionLibrary::GetCakePlacer(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetCakePlacer");

	USTExtraBlueprintFunctionLibrary_GetCakePlacer_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetBackpackComponentFromController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AController*             Controller                     (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBackpackComponent* USTExtraBlueprintFunctionLibrary::GetBackpackComponentFromController(class AController* Controller)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetBackpackComponentFromController");

	USTExtraBlueprintFunctionLibrary_GetBackpackComponentFromController_Params params;
	params.Controller = Controller;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetBackpackComponentFromCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ACharacter*              Character                      (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackComponent*      ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UBackpackComponent* USTExtraBlueprintFunctionLibrary::GetBackpackComponentFromCharacter(class ACharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetBackpackComponentFromCharacter");

	USTExtraBlueprintFunctionLibrary_GetBackpackComponentFromCharacter_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReferenceAsyncWithID
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FSoftObjectPath         AssetReference                 (Parm)
// struct FScriptDelegate         AssetLoadSuccessDelegate       (Parm, ZeroConstructor)
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::GetAssetByAssetReferenceAsyncWithID(const struct FSoftObjectPath& AssetReference, const struct FScriptDelegate& AssetLoadSuccessDelegate, int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReferenceAsyncWithID");

	USTExtraBlueprintFunctionLibrary_GetAssetByAssetReferenceAsyncWithID_Params params;
	params.AssetReference = AssetReference;
	params.AssetLoadSuccessDelegate = AssetLoadSuccessDelegate;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReferenceAsync
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FSoftObjectPath         AssetReference                 (Parm)
// struct FScriptDelegate         AssetLoadSuccessDelegate       (Parm, ZeroConstructor)

void USTExtraBlueprintFunctionLibrary::GetAssetByAssetReferenceAsync(const struct FSoftObjectPath& AssetReference, const struct FScriptDelegate& AssetLoadSuccessDelegate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReferenceAsync");

	USTExtraBlueprintFunctionLibrary_GetAssetByAssetReferenceAsync_Params params;
	params.AssetReference = AssetReference;
	params.AssetLoadSuccessDelegate = AssetLoadSuccessDelegate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReference
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FSoftObjectPath         AssetReference                 (Parm)
// class UObject*                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UObject* USTExtraBlueprintFunctionLibrary::GetAssetByAssetReference(const struct FSoftObjectPath& AssetReference)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.GetAssetByAssetReference");

	USTExtraBlueprintFunctionLibrary_GetAssetByAssetReference_Params params;
	params.AssetReference = AssetReference;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.Generate3StageBezierPointsSrcToDst
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 Src                            (Parm, IsPlainOldData)
// struct FVector                 Ctl                            (Parm, IsPlainOldData)
// struct FVector                 Dst                            (Parm, IsPlainOldData)
// int                            Num                            (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FVector>         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FVector> USTExtraBlueprintFunctionLibrary::Generate3StageBezierPointsSrcToDst(const struct FVector& Src, const struct FVector& Ctl, const struct FVector& Dst, int Num)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.Generate3StageBezierPointsSrcToDst");

	USTExtraBlueprintFunctionLibrary_Generate3StageBezierPointsSrcToDst_Params params;
	params.Src = Src;
	params.Ctl = Ctl;
	params.Dst = Dst;
	params.Num = Num;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.FlushSlateZBufferWriteState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UWorld*                  World                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::FlushSlateZBufferWriteState(class UWorld* World)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.FlushSlateZBufferWriteState");

	USTExtraBlueprintFunctionLibrary_FlushSlateZBufferWriteState_Params params;
	params.World = World;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.DestroyActorWithParam
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Target                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bForce                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bModifyLevel                   (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::DestroyActorWithParam(class AActor* Target, bool bForce, bool bModifyLevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.DestroyActorWithParam");

	USTExtraBlueprintFunctionLibrary_DestroyActorWithParam_Params params;
	params.Target = Target;
	params.bForce = bForce;
	params.bModifyLevel = bModifyLevel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.CreateMyLandscape
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 MatPath                        (Parm, ZeroConstructor)
// struct FString                 GeoPath                        (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::CreateMyLandscape(class UObject* WorldContextObject, const struct FString& MatPath, const struct FString& GeoPath)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.CreateMyLandscape");

	USTExtraBlueprintFunctionLibrary_CreateMyLandscape_Params params;
	params.WorldContextObject = WorldContextObject;
	params.MatPath = MatPath;
	params.GeoPath = GeoPath;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ComponentIsVisibleFromExplosionWithEndPosition
// (Final, Native, Static, Public, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     VictimComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 Origin                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 EndPos                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class AActor*                  IgnoredActor                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TEnumAsByte<ECollisionChannel> TraceChannel                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           DrawVisibleTraceDebugLine      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsConsideringVehicleBlock      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::ComponentIsVisibleFromExplosionWithEndPosition(class UPrimitiveComponent* VictimComp, const struct FVector& Origin, const struct FVector& EndPos, class AActor* IgnoredActor, TArray<class AActor*> IgnoreActors, TEnumAsByte<ECollisionChannel> TraceChannel, bool DrawVisibleTraceDebugLine, bool IsConsideringVehicleBlock)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ComponentIsVisibleFromExplosionWithEndPosition");

	USTExtraBlueprintFunctionLibrary_ComponentIsVisibleFromExplosionWithEndPosition_Params params;
	params.VictimComp = VictimComp;
	params.Origin = Origin;
	params.EndPos = EndPos;
	params.IgnoredActor = IgnoredActor;
	params.IgnoreActors = IgnoreActors;
	params.TraceChannel = TraceChannel;
	params.DrawVisibleTraceDebugLine = DrawVisibleTraceDebugLine;
	params.IsConsideringVehicleBlock = IsConsideringVehicleBlock;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ComponentIsVisibleFromExplosion
// (Final, Native, Static, Public, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     VictimComp                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 Origin                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class AActor*                  IgnoredActor                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TEnumAsByte<ECollisionChannel> TraceChannel                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           DrawVisibleTraceDebugLine      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsConsideringVehicleBlock      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::ComponentIsVisibleFromExplosion(class UPrimitiveComponent* VictimComp, const struct FVector& Origin, class AActor* IgnoredActor, TArray<class AActor*> IgnoreActors, TEnumAsByte<ECollisionChannel> TraceChannel, bool DrawVisibleTraceDebugLine, bool IsConsideringVehicleBlock)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ComponentIsVisibleFromExplosion");

	USTExtraBlueprintFunctionLibrary_ComponentIsVisibleFromExplosion_Params params;
	params.VictimComp = VictimComp;
	params.Origin = Origin;
	params.IgnoredActor = IgnoredActor;
	params.IgnoreActors = IgnoreActors;
	params.TraceChannel = TraceChannel;
	params.DrawVisibleTraceDebugLine = DrawVisibleTraceDebugLine;
	params.IsConsideringVehicleBlock = IsConsideringVehicleBlock;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ApplyRadiusDamageSTEWithMomentum
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          MinimumDamage                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          BaseMomentumMag                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Origin                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          DamageInnerRadius              (Parm, ZeroConstructor, IsPlainOldData)
// float                          DamageOuterRadius              (Parm, ZeroConstructor, IsPlainOldData)
// float                          DamageFalloff                  (Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  DamageTypeClass                (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedByController         (Parm, ZeroConstructor, IsPlainOldData)
// float                          CollisionFreeRadius            (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          DamagedTarget                  (Parm, OutParm, ZeroConstructor)
// float                          AddtionalDamage                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsVehicleExplode               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           DrawVisibleTraceDebugLine      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::ApplyRadiusDamageSTEWithMomentum(class UObject* WorldContextObject, float BaseDamage, float MinimumDamage, float BaseMomentumMag, const struct FVector& Origin, float DamageInnerRadius, float DamageOuterRadius, float DamageFalloff, class UClass* DamageTypeClass, TArray<class AActor*> IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, float CollisionFreeRadius, bool DrawVisibleTraceDebugLine, float AddtionalDamage, bool IsVehicleExplode, TArray<class AActor*>* DamagedTarget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ApplyRadiusDamageSTEWithMomentum");

	USTExtraBlueprintFunctionLibrary_ApplyRadiusDamageSTEWithMomentum_Params params;
	params.WorldContextObject = WorldContextObject;
	params.BaseDamage = BaseDamage;
	params.MinimumDamage = MinimumDamage;
	params.BaseMomentumMag = BaseMomentumMag;
	params.Origin = Origin;
	params.DamageInnerRadius = DamageInnerRadius;
	params.DamageOuterRadius = DamageOuterRadius;
	params.DamageFalloff = DamageFalloff;
	params.DamageTypeClass = DamageTypeClass;
	params.IgnoreActors = IgnoreActors;
	params.DamageCauser = DamageCauser;
	params.InstigatedByController = InstigatedByController;
	params.CollisionFreeRadius = CollisionFreeRadius;
	params.AddtionalDamage = AddtionalDamage;
	params.IsVehicleExplode = IsVehicleExplode;
	params.DrawVisibleTraceDebugLine = DrawVisibleTraceDebugLine;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DamagedTarget != nullptr)
		*DamagedTarget = params.DamagedTarget;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ApplyRadiusDamageSTE
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (Parm, ZeroConstructor, IsPlainOldData)
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          MinimumDamage                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 Origin                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          DamageInnerRadius              (Parm, ZeroConstructor, IsPlainOldData)
// float                          DamageOuterRadius              (Parm, ZeroConstructor, IsPlainOldData)
// float                          DamageFalloff                  (Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  DamageTypeClass                (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             InstigatedByController         (Parm, ZeroConstructor, IsPlainOldData)
// float                          CollisionFreeRadius            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           DrawVisibleTraceDebugLine      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraBlueprintFunctionLibrary::ApplyRadiusDamageSTE(class UObject* WorldContextObject, float BaseDamage, float MinimumDamage, const struct FVector& Origin, float DamageInnerRadius, float DamageOuterRadius, float DamageFalloff, class UClass* DamageTypeClass, TArray<class AActor*> IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, float CollisionFreeRadius, bool DrawVisibleTraceDebugLine)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.ApplyRadiusDamageSTE");

	USTExtraBlueprintFunctionLibrary_ApplyRadiusDamageSTE_Params params;
	params.WorldContextObject = WorldContextObject;
	params.BaseDamage = BaseDamage;
	params.MinimumDamage = MinimumDamage;
	params.Origin = Origin;
	params.DamageInnerRadius = DamageInnerRadius;
	params.DamageOuterRadius = DamageOuterRadius;
	params.DamageFalloff = DamageFalloff;
	params.DamageTypeClass = DamageTypeClass;
	params.IgnoreActors = IgnoreActors;
	params.DamageCauser = DamageCauser;
	params.InstigatedByController = InstigatedByController;
	params.CollisionFreeRadius = CollisionFreeRadius;
	params.DrawVisibleTraceDebugLine = DrawVisibleTraceDebugLine;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.AddDistributedImpulseAtLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class USkeletalMeshComponent*  SkelMesh                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 Impulse                        (Parm, IsPlainOldData)
// struct FVector                 Location                       (Parm, IsPlainOldData)
// struct FName                   BoneName                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          DistriburedImpulseScale        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBlueprintFunctionLibrary::AddDistributedImpulseAtLocation(class USkeletalMeshComponent* SkelMesh, const struct FVector& Impulse, const struct FVector& Location, const struct FName& BoneName, float DistriburedImpulseScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBlueprintFunctionLibrary.AddDistributedImpulseAtLocation");

	USTExtraBlueprintFunctionLibrary_AddDistributedImpulseAtLocation_Params params;
	params.SkelMesh = SkelMesh;
	params.Impulse = Impulse;
	params.Location = Location;
	params.BoneName = BoneName;
	params.DistriburedImpulseScale = DistriburedImpulseScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBuffApplierComponent.SetIsEnableChecking
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           Enable                         (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBuffApplierComponent::SetIsEnableChecking(bool Enable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBuffApplierComponent.SetIsEnableChecking");

	USTExtraBuffApplierComponent_SetIsEnableChecking_Params params;
	params.Enable = Enable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBuffApplierComponent.OverlapCheckerOneTarget
// (Final, Native, Protected)
// Parameters:
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraBuffApplierComponent::OverlapCheckerOneTarget(class AActor* OtherActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBuffApplierComponent.OverlapCheckerOneTarget");

	USTExtraBuffApplierComponent_OverlapCheckerOneTarget_Params params;
	params.OtherActor = OtherActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffLayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USTBaseBuff*             Buff                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraBuffLibrary::GetBuffLayer(class USTBaseBuff* Buff)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffLayer");

	USTExtraBuffLibrary_GetBuffLayer_Params params;
	params.Buff = Buff;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffByName
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                  BuffOwner                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   Name                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// class USTBaseBuff*             ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USTBaseBuff* USTExtraBuffLibrary::GetBuffByName(class AActor* BuffOwner, const struct FName& Name)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffByName");

	USTExtraBuffLibrary_GetBuffByName_Params params;
	params.BuffOwner = BuffOwner;
	params.Name = Name;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffActions
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// class USTBaseBuff*             Buff                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TArray<class UUTSkillAction*>  BuffActions                    (Parm, OutParm, ZeroConstructor)

void USTExtraBuffLibrary::GetBuffActions(class USTBaseBuff* Buff, TArray<class UUTSkillAction*>* BuffActions)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraBuffLibrary.GetBuffActions");

	USTExtraBuffLibrary_GetBuffActions_Params params;
	params.Buff = Buff;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (BuffActions != nullptr)
		*BuffActions = params.BuffActions;
}


// Function ShadowTrackerExtra.STExtraDelegateMgr.STExtraDelegateMgrInstance
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class USTExtraDelegateMgr*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USTExtraDelegateMgr* USTExtraDelegateMgr::STExtraDelegateMgrInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraDelegateMgr.STExtraDelegateMgrInstance");

	USTExtraDelegateMgr_STExtraDelegateMgrInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraExplosiveActor.Explode
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class APawn*                   InstigatorPawn                 (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class AActor*>          IgnoreActors                   (Parm, ZeroConstructor)
// struct FVector                 Origin                         (Parm, IsPlainOldData)
// bool                           bReplicateToClients            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraExplosiveActor::Explode(class APawn* InstigatorPawn, class AActor* DamageCauser, TArray<class AActor*> IgnoreActors, const struct FVector& Origin, bool bReplicateToClients)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraExplosiveActor.Explode");

	ASTExtraExplosiveActor_Explode_Params params;
	params.InstigatorPawn = InstigatorPawn;
	params.DamageCauser = DamageCauser;
	params.IgnoreActors = IgnoreActors;
	params.Origin = Origin;
	params.bReplicateToClients = bReplicateToClients;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraFlareGunBullet.RPC_Multicast_EnterPhase2
// (Net, NetReliable, Native, Event, NetMulticast, Protected, NetValidate)

void ASTExtraFlareGunBullet::RPC_Multicast_EnterPhase2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFlareGunBullet.RPC_Multicast_EnterPhase2");

	ASTExtraFlareGunBullet_RPC_Multicast_EnterPhase2_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraFlareGunBullet.OnBounce
// (Native, Protected, HasOutParms, HasDefaults)
// Parameters:
// struct FHitResult              _ImpactResult                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 _ImpactVelocity                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraFlareGunBullet::OnBounce(const struct FHitResult& _ImpactResult, const struct FVector& _ImpactVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFlareGunBullet.OnBounce");

	ASTExtraFlareGunBullet_OnBounce_Params params;
	params._ImpactResult = _ImpactResult;
	params._ImpactVelocity = _ImpactVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.VehicleBeenDestroyedCleanInfoDisplay
// (Final, Native, Private)
// Parameters:
// ESTExtraVehicleHealthState     InVehicleHealthState           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::VehicleBeenDestroyedCleanInfoDisplay(ESTExtraVehicleHealthState InVehicleHealthState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.VehicleBeenDestroyedCleanInfoDisplay");

	ASTExtraVehicleBase_VehicleBeenDestroyedCleanInfoDisplay_Params params;
	params.InVehicleHealthState = InVehicleHealthState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.StartAirDrop
// (Final, Native, Public, BlueprintCallable)

void ASTExtraVehicleBase::StartAirDrop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.StartAirDrop");

	ASTExtraVehicleBase_StartAirDrop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetUsingHorn
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           bUse                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::ServerSetUsingHorn(bool bUse)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetUsingHorn");

	ASTExtraVehicleBase_ServerSetUsingHorn_Params params;
	params.bUse = bUse;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetIsVehicleSpringArmAutoReturn
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           bEnalbed                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::ServerSetIsVehicleSpringArmAutoReturn(bool bEnalbed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetIsVehicleSpringArmAutoReturn");

	ASTExtraVehicleBase_ServerSetIsVehicleSpringArmAutoReturn_Params params;
	params.bEnalbed = bEnalbed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetBoosting
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           bEnalbed                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::ServerSetBoosting(bool bEnalbed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ServerSetBoosting");

	ASTExtraVehicleBase_ServerSetBoosting_Params params;
	params.bEnalbed = bEnalbed;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.SendTriggerEventToServer
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class UVehicleTriggerComponent* VTComp                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void ASTExtraVehicleBase::SendTriggerEventToServer(class UVehicleTriggerComponent* VTComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.SendTriggerEventToServer");

	ASTExtraVehicleBase_SendTriggerEventToServer_Params params;
	params.VTComp = VTComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.RemoveAntiStuckBox
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraVehicleBase::RemoveAntiStuckBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.RemoveAntiStuckBox");

	ASTExtraVehicleBase_RemoveAntiStuckBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.PostLoadFPPMesh
// (Native, Public, BlueprintCallable)

void ASTExtraVehicleBase::PostLoadFPPMesh()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.PostLoadFPPMesh");

	ASTExtraVehicleBase_PostLoadFPPMesh_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.PlaySfxOneShot
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UAkAudioEvent*           AkEvent                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::PlaySfxOneShot(class UAkAudioEvent* AkEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.PlaySfxOneShot");

	ASTExtraVehicleBase_PlaySfxOneShot_Params params;
	params.AkEvent = AkEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnUpdateEffects
// (Event, Public, BlueprintEvent)

void ASTExtraVehicleBase::OnUpdateEffects()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnUpdateEffects");

	ASTExtraVehicleBase_OnUpdateEffects_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnSetTailLightValue
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          LightValue                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::OnSetTailLightValue(float LightValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnSetTailLightValue");

	ASTExtraVehicleBase_OnSetTailLightValue_Params params;
	params.LightValue = LightValue;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_VehicleHealthState
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_VehicleHealthState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_VehicleHealthState");

	ASTExtraVehicleBase_OnRep_VehicleHealthState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_SimulateViewData
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_SimulateViewData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_SimulateViewData");

	ASTExtraVehicleBase_OnRep_SimulateViewData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_SimulateFreeCameraViewData
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_SimulateFreeCameraViewData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_SimulateFreeCameraViewData");

	ASTExtraVehicleBase_OnRep_SimulateFreeCameraViewData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsVehicleSpringArmAutoReturn
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_IsVehicleSpringArmAutoReturn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsVehicleSpringArmAutoReturn");

	ASTExtraVehicleBase_OnRep_IsVehicleSpringArmAutoReturn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsEngineStarted
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_IsEngineStarted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsEngineStarted");

	ASTExtraVehicleBase_OnRep_IsEngineStarted_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsBoosting
// (Final, Native, Public)

void ASTExtraVehicleBase::OnRep_IsBoosting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsBoosting");

	ASTExtraVehicleBase_OnRep_IsBoosting_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsAirdroppingVehicle
// (Final, Native, Protected)

void ASTExtraVehicleBase::OnRep_IsAirdroppingVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnRep_IsAirdroppingVehicle");

	ASTExtraVehicleBase_OnRep_IsAirdroppingVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnMeshLoaded
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FSoftObjectPath         AssetRef                       (Parm)

void ASTExtraVehicleBase::OnMeshLoaded(const struct FSoftObjectPath& AssetRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnMeshLoaded");

	ASTExtraVehicleBase_OnMeshLoaded_Params params;
	params.AssetRef = AssetRef;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnEngineStop
// (Event, Public, BlueprintEvent)

void ASTExtraVehicleBase::OnEngineStop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnEngineStop");

	ASTExtraVehicleBase_OnEngineStop_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnEngineStart
// (Event, Public, BlueprintEvent)

void ASTExtraVehicleBase::OnEngineStart()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnEngineStart");

	ASTExtraVehicleBase_OnEngineStart_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.OnBoostingChanged
// (Event, Public, BlueprintEvent)

void ASTExtraVehicleBase::OnBoostingChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.OnBoostingChanged");

	ASTExtraVehicleBase_OnBoostingChanged_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.MultiCast_ApplyImpulse
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 Origin                         (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// float                          DamageOuterRadius              (Parm, ZeroConstructor, IsPlainOldData)
// float                          BaseMomentumMag                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::MultiCast_ApplyImpulse(const struct FVector& Origin, float DamageOuterRadius, float BaseMomentumMag)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.MultiCast_ApplyImpulse");

	ASTExtraVehicleBase_MultiCast_ApplyImpulse_Params params;
	params.Origin = Origin;
	params.DamageOuterRadius = DamageOuterRadius;
	params.BaseMomentumMag = BaseMomentumMag;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.LoadFPPVehicleModel
// (Final, Native, Public)

void ASTExtraVehicleBase::LoadFPPVehicleModel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.LoadFPPVehicleModel");

	ASTExtraVehicleBase_LoadFPPVehicleModel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.IsUsingFPPModel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraVehicleBase::IsUsingFPPModel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.IsUsingFPPModel");

	ASTExtraVehicleBase_IsUsingFPPModel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.IsInMidAir
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraVehicleBase::IsInMidAir()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.IsInMidAir");

	ASTExtraVehicleBase_IsInMidAir_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.IsEntirelyUnderWater
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraVehicleBase::IsEntirelyUnderWater()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.IsEntirelyUnderWater");

	ASTExtraVehicleBase_IsEntirelyUnderWater_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.InitVehicle
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            FuelPercent                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bEngineOn                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::InitVehicle(int FuelPercent, bool bEngineOn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.InitVehicle");

	ASTExtraVehicleBase_InitVehicle_Params params;
	params.FuelPercent = FuelPercent;
	params.bEngineOn = bEngineOn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.InitSkeletalMesh
// (Final, Native, Public)
// Parameters:
// struct FName                   SubobjectName                  (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMeshComponent*  ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USkeletalMeshComponent* ASTExtraVehicleBase::InitSkeletalMesh(const struct FName& SubobjectName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.InitSkeletalMesh");

	ASTExtraVehicleBase_InitSkeletalMesh_Params params;
	params.SubobjectName = SubobjectName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnVehicleHealthStateChanged
// (Native, Protected)
// Parameters:
// ESTExtraVehicleHealthState     InVehicleHealthState           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::HandleOnVehicleHealthStateChanged(ESTExtraVehicleHealthState InVehicleHealthState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnVehicleHealthStateChanged");

	ASTExtraVehicleBase_HandleOnVehicleHealthStateChanged_Params params;
	params.InVehicleHealthState = InVehicleHealthState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatDetached
// (Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::HandleOnSeatDetached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatDetached");

	ASTExtraVehicleBase_HandleOnSeatDetached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatChanged
// (Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        LastSeatType                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            LastSeatIdx                    (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        NewSeatType                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewSeatIdx                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::HandleOnSeatChanged(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType LastSeatType, int LastSeatIdx, ESTExtraVehicleSeatType NewSeatType, int NewSeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatChanged");

	ASTExtraVehicleBase_HandleOnSeatChanged_Params params;
	params.Character = Character;
	params.LastSeatType = LastSeatType;
	params.LastSeatIdx = LastSeatIdx;
	params.NewSeatType = NewSeatType;
	params.NewSeatIdx = NewSeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatAttached
// (Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraVehicleBase::HandleOnSeatAttached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnSeatAttached");

	ASTExtraVehicleBase_HandleOnSeatAttached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnMeshHit
// (Final, Native, Protected, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     HitComponent                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraVehicleBase::HandleOnMeshHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.HandleOnMeshHit");

	ASTExtraVehicleBase_HandleOnMeshHit_Params params;
	params.HitComponent = HitComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.GetSoftRefObj
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FSoftObjectPath         AssetRef                       (Parm, OutParm)
// class UObject*                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UObject* ASTExtraVehicleBase::GetSoftRefObj(struct FSoftObjectPath* AssetRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.GetSoftRefObj");

	ASTExtraVehicleBase_GetSoftRefObj_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (AssetRef != nullptr)
		*AssetRef = params.AssetRef;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.GetRotationInputDir
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraVehicleBase::GetRotationInputDir()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.GetRotationInputDir");

	ASTExtraVehicleBase_GetRotationInputDir_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.GetForwardSpeed
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraVehicleBase::GetForwardSpeed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.GetForwardSpeed");

	ASTExtraVehicleBase_GetForwardSpeed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ExitFPPVehicle
// (Final, Native, Public)

void ASTExtraVehicleBase::ExitFPPVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ExitFPPVehicle");

	ASTExtraVehicleBase_ExitFPPVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.EnterFPPVehicle
// (Final, Native, Public)

void ASTExtraVehicleBase::EnterFPPVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.EnterFPPVehicle");

	ASTExtraVehicleBase_EnterFPPVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.DestroyAndRespawnSelf
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraVehicleBase::DestroyAndRespawnSelf()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.DestroyAndRespawnSelf");

	ASTExtraVehicleBase_DestroyAndRespawnSelf_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.CreateAntiStuckBox
// (Final, Native, Protected, BlueprintCallable)

void ASTExtraVehicleBase::CreateAntiStuckBox()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.CreateAntiStuckBox");

	ASTExtraVehicleBase_CreateAntiStuckBox_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ClearInputs
// (Final, Native, Public, BlueprintCallable)

void ASTExtraVehicleBase::ClearInputs()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ClearInputs");

	ASTExtraVehicleBase_ClearInputs_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.BroadcastClientVehicleExplosionEffect
// (Net, Native, Event, NetMulticast, Public)

void ASTExtraVehicleBase::BroadcastClientVehicleExplosionEffect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.BroadcastClientVehicleExplosionEffect");

	ASTExtraVehicleBase_BroadcastClientVehicleExplosionEffect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.ApplyAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraVehicleBase::ApplyAnimation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.ApplyAnimation");

	ASTExtraVehicleBase_ApplyAnimation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleBase.AfterBeginPlay
// (Event, Public, BlueprintEvent)

void ASTExtraVehicleBase::AfterBeginPlay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleBase.AfterBeginPlay");

	ASTExtraVehicleBase_AfterBeginPlay_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraFloatingVehicle.HandleOnMeshAwake
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*     WakingComponent                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FName                   BoneName                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraFloatingVehicle::HandleOnMeshAwake(class UPrimitiveComponent* WakingComponent, const struct FName& BoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFloatingVehicle.HandleOnMeshAwake");

	ASTExtraFloatingVehicle_HandleOnMeshAwake_Params params;
	params.WakingComponent = WakingComponent;
	params.BoneName = BoneName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraFloatingVehicle.GetRotationInputDir
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraFloatingVehicle::GetRotationInputDir()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFloatingVehicle.GetRotationInputDir");

	ASTExtraFloatingVehicle_GetRotationInputDir_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.ServerUpdateInput
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// float                          InSteeringInput                (Parm, ZeroConstructor, IsPlainOldData)
// float                          InThrottleInput                (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraFloatingVehicleMovementComponent::ServerUpdateInput(float InSteeringInput, float InThrottleInput)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.ServerUpdateInput");

	USTExtraFloatingVehicleMovementComponent_ServerUpdateInput_Params params;
	params.InSteeringInput = InSteeringInput;
	params.InThrottleInput = InThrottleInput;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.GetThrottleInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraFloatingVehicleMovementComponent::GetThrottleInput()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.GetThrottleInput");

	USTExtraFloatingVehicleMovementComponent_GetThrottleInput_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.GetSteeringInput
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraFloatingVehicleMovementComponent::GetSteeringInput()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFloatingVehicleMovementComponent.GetSteeringInput");

	USTExtraFloatingVehicleMovementComponent_GetSteeringInput_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraFPPAnimInstance.CacheParamList
// (Native, Public)
// Parameters:
// float                          DeltaSeconds                   (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraFPPAnimInstance::CacheParamList(float DeltaSeconds)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraFPPAnimInstance.CacheParamList");

	USTExtraFPPAnimInstance_CacheParamList_Params params;
	params.DeltaSeconds = DeltaSeconds;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraGameInstance.UserQualitySettingChanged__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// int                            UserQualitySettingLevel        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::UserQualitySettingChanged__DelegateSignature(int UserQualitySettingLevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraGameInstance.UserQualitySettingChanged__DelegateSignature");

	USTExtraGameInstance_UserQualitySettingChanged__DelegateSignature_Params params;
	params.UserQualitySettingLevel = UserQualitySettingLevel;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetWorldCompositionRelativeDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            LODIndex                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          Distance                       (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::SetWorldCompositionRelativeDistance(int LODIndex, float Distance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetWorldCompositionRelativeDistance");

	USTExtraGameInstance_SetWorldCompositionRelativeDistance_Params params;
	params.LODIndex = LODIndex;
	params.Distance = Distance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetUserSetingShadowQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bShadow                        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::SetUserSetingShadowQuality(bool bShadow)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetUserSetingShadowQuality");

	USTExtraGameInstance_SetUserSetingShadowQuality_Params params;
	params.bShadow = bShadow;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetUserSetingMobilceContentSCale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          mcs                            (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::SetUserSetingMobilceContentSCale(float mcs)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetUserSetingMobilceContentSCale");

	USTExtraGameInstance_SetUserSetingMobilceContentSCale_Params params;
	params.mcs = mcs;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetSoundEffectQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Type                           (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::SetSoundEffectQuality(int Type)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetSoundEffectQuality");

	USTExtraGameInstance_SetSoundEffectQuality_Params params;
	params.Type = Type;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetRenderQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FRenderQualitySettings  RenderQualitySettings          (Parm)

void USTExtraGameInstance::SetRenderQuality(const struct FRenderQualitySettings& RenderQualitySettings)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetRenderQuality");

	USTExtraGameInstance_SetRenderQuality_Params params;
	params.RenderQualitySettings = RenderQualitySettings;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetIsEmulatorInitFireMode
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::SetIsEmulatorInitFireMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetIsEmulatorInitFireMode");

	USTExtraGameInstance_SetIsEmulatorInitFireMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetHZBMobileState
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::SetHZBMobileState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetHZBMobileState");

	USTExtraGameInstance_SetHZBMobileState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetFOVScreenSizeCullingFactor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          FOV                            (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::SetFOVScreenSizeCullingFactor(float FOV)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetFOVScreenSizeCullingFactor");

	USTExtraGameInstance_SetFOVScreenSizeCullingFactor_Params params;
	params.FOV = FOV;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetCustomRouteLine
// (Final, Native, Static, Public, BlueprintCallable)

void USTExtraGameInstance::SetCustomRouteLine()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetCustomRouteLine");

	USTExtraGameInstance_SetCustomRouteLine_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.SetAutoMissionType
// (Final, Native, Static, Public, BlueprintCallable)

void USTExtraGameInstance::SetAutoMissionType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.SetAutoMissionType");

	USTExtraGameInstance_SetAutoMissionType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ReSetFOVScreenSizeCullingFactor
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::ReSetFOVScreenSizeCullingFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ReSetFOVScreenSizeCullingFactor");

	USTExtraGameInstance_ReSetFOVScreenSizeCullingFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.RenderForLowFPS
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::RenderForLowFPS()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.RenderForLowFPS");

	USTExtraGameInstance_RenderForLowFPS_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.RefuseRenderForLowFPS
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::RefuseRenderForLowFPS()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.RefuseRenderForLowFPS");

	USTExtraGameInstance_RefuseRenderForLowFPS_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.QuitGame
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::QuitGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.QuitGame");

	USTExtraGameInstance_QuitGame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.PreSetRenderQuality
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FRenderQualitySettings  RenderQualitySettings          (Parm)
// bool                           renderLevelChanged             (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::PreSetRenderQuality(const struct FRenderQualitySettings& RenderQualitySettings, bool* renderLevelChanged)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.PreSetRenderQuality");

	USTExtraGameInstance_PreSetRenderQuality_Params params;
	params.RenderQualitySettings = RenderQualitySettings;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (renderLevelChanged != nullptr)
		*renderLevelChanged = params.renderLevelChanged;
}


// Function ShadowTrackerExtra.STExtraGameInstance.isUsingAssumedNameInReplay
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::isUsingAssumedNameInReplay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.isUsingAssumedNameInReplay");

	USTExtraGameInstance_isUsingAssumedNameInReplay_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsSupportTagCulling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsSupportTagCulling()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsSupportTagCulling");

	USTExtraGameInstance_IsSupportTagCulling_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsSupportSwitchSoundEffectQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsSupportSwitchSoundEffectQuality()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsSupportSwitchSoundEffectQuality");

	USTExtraGameInstance_IsSupportSwitchSoundEffectQuality_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsSupportSwitchRenderLevelRuntime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsSupportSwitchRenderLevelRuntime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsSupportSwitchRenderLevelRuntime");

	USTExtraGameInstance_IsSupportSwitchRenderLevelRuntime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsSupportMSAA
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsSupportMSAA()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsSupportMSAA");

	USTExtraGameInstance_IsSupportMSAA_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsSupportLDR
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsSupportLDR()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsSupportLDR");

	USTExtraGameInstance_IsSupportLDR_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsOpenHDR
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsOpenHDR()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsOpenHDR");

	USTExtraGameInstance_IsOpenHDR_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.IsAutoRunTestGame
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::IsAutoRunTestGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.IsAutoRunTestGame");

	USTExtraGameInstance_IsAutoRunTestGame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GMStandalone
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 Map                            (Parm, ZeroConstructor)

void USTExtraGameInstance::GMStandalone(const struct FString& Map)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GMStandalone");

	USTExtraGameInstance_GMStandalone_Params params;
	params.Map = Map;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetWonderfulRecordingCut
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UWonderfulRecordingCut*  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UWonderfulRecordingCut* USTExtraGameInstance::GetWonderfulRecordingCut()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetWonderfulRecordingCut");

	USTExtraGameInstance_GetWonderfulRecordingCut_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetUserSetingShadowQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::GetUserSetingShadowQuality()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetUserSetingShadowQuality");

	USTExtraGameInstance_GetUserSetingShadowQuality_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetUserQualitySettingLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetUserQualitySettingLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetUserQualitySettingLevel");

	USTExtraGameInstance_GetUserQualitySettingLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetSoundEffectQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetSoundEffectQuality()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetSoundEffectQuality");

	USTExtraGameInstance_GetSoundEffectQuality_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetRenderQualityLastSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRenderQualitySettings  ReturnValue                    (Parm, OutParm, ReturnParm)

struct FRenderQualitySettings USTExtraGameInstance::GetRenderQualityLastSet()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetRenderQualityLastSet");

	USTExtraGameInstance_GetRenderQualityLastSet_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetRenderQualityApplying
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRenderQualitySettings  ReturnValue                    (Parm, OutParm, ReturnParm)

struct FRenderQualitySettings USTExtraGameInstance::GetRenderQualityApplying()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetRenderQualityApplying");

	USTExtraGameInstance_GetRenderQualityApplying_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetIsEmulatorInitFireMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::GetIsEmulatorInitFireMode()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetIsEmulatorInitFireMode");

	USTExtraGameInstance_GetIsEmulatorInitFireMode_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceUpdateVersionFlag
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetDeviceUpdateVersionFlag()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceUpdateVersionFlag");

	USTExtraGameInstance_GetDeviceUpdateVersionFlag_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceMaxSupportLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ERenderQuality>    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ERenderQuality> USTExtraGameInstance::GetDeviceMaxSupportLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceMaxSupportLevel");

	USTExtraGameInstance_GetDeviceMaxSupportLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceMaxFPSByDeviceLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ERenderQuality>    renderlevel                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetDeviceMaxFPSByDeviceLevel(TEnumAsByte<ERenderQuality> renderlevel)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceMaxFPSByDeviceLevel");

	USTExtraGameInstance_GetDeviceMaxFPSByDeviceLevel_Params params;
	params.renderlevel = renderlevel;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceLimit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetDeviceLimit()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceLimit");

	USTExtraGameInstance_GetDeviceLimit_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceLevel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetDeviceLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeviceLevel");

	USTExtraGameInstance_GetDeviceLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDefaultSoundEffectQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::GetDefaultSoundEffectQuality()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDefaultSoundEffectQuality");

	USTExtraGameInstance_GetDefaultSoundEffectQuality_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetDeathPlayback
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UDeathPlayback*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UDeathPlayback* USTExtraGameInstance::GetDeathPlayback()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetDeathPlayback");

	USTExtraGameInstance_GetDeathPlayback_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetCompletePlayback
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCompletePlayback*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UCompletePlayback* USTExtraGameInstance::GetCompletePlayback()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetCompletePlayback");

	USTExtraGameInstance_GetCompletePlayback_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunTestServerIdx
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraGameInstance::GetAutoRunTestServerIdx()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunTestServerIdx");

	USTExtraGameInstance_GetAutoRunTestServerIdx_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunPassWD
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraGameInstance::GetAutoRunPassWD()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunPassWD");

	USTExtraGameInstance_GetAutoRunPassWD_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunLuaTest
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraGameInstance::GetAutoRunLuaTest()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunLuaTest");

	USTExtraGameInstance_GetAutoRunLuaTest_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunAccount
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraGameInstance::GetAutoRunAccount()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetAutoRunAccount");

	USTExtraGameInstance_GetAutoRunAccount_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.GetApplyingShadowQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::GetApplyingShadowQuality()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.GetApplyingShadowQuality");

	USTExtraGameInstance_GetApplyingShadowQuality_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ExecuteCMD
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 CMDkey                         (Parm, ZeroConstructor)
// struct FString                 CMDvalue                       (Parm, ZeroConstructor)

void USTExtraGameInstance::ExecuteCMD(const struct FString& CMDkey, const struct FString& CMDvalue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ExecuteCMD");

	USTExtraGameInstance_ExecuteCMD_Params params;
	params.CMDkey = CMDkey;
	params.CMDvalue = CMDvalue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.EnableStreamingLevelLOD
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::EnableStreamingLevelLOD(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.EnableStreamingLevelLOD");

	USTExtraGameInstance_EnableStreamingLevelLOD_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.EnableDeathPlayback
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFlush                         (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::EnableDeathPlayback(bool bEnable, bool bFlush)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.EnableDeathPlayback");

	USTExtraGameInstance_EnableDeathPlayback_Params params;
	params.bEnable = bEnable;
	params.bFlush = bFlush;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.DeleteSavedFiles
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           allfilesSaved                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameInstance::DeleteSavedFiles(bool allfilesSaved)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.DeleteSavedFiles");

	USTExtraGameInstance_DeleteSavedFiles_Params params;
	params.allfilesSaved = allfilesSaved;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameInstance.AutoActiveLDR
// (Final, Native, Public, BlueprintCallable)

void USTExtraGameInstance::AutoActiveLDR()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.AutoActiveLDR");

	USTExtraGameInstance_AutoActiveLDR_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ActiveStyle_PP
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ERenderStyle>      Level                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::ActiveStyle_PP(TEnumAsByte<ERenderStyle> Level)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ActiveStyle_PP");

	USTExtraGameInstance_ActiveStyle_PP_Params params;
	params.Level = Level;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ActiveStyle
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ERenderStyle>      Level                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::ActiveStyle(TEnumAsByte<ERenderStyle> Level)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ActiveStyle");

	USTExtraGameInstance_ActiveStyle_Params params;
	params.Level = Level;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ActiveNightVision
// (Final, Exec, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bSet                           (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::ActiveNightVision(bool bSet)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ActiveNightVision");

	USTExtraGameInstance_ActiveNightVision_Params params;
	params.bSet = bSet;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameInstance.ActiveMSAA
// (Final, Native, Public)
// Parameters:
// bool                           bOpenMSAA                      (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameInstance::ActiveMSAA(bool bOpenMSAA)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameInstance.ActiveMSAA");

	USTExtraGameInstance_ActiveMSAA_Params params;
	params.bOpenMSAA = bOpenMSAA;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameMode.OnGameEnd
// (Final, Native, Public)

void ASTExtraGameMode::OnGameEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameMode.OnGameEnd");

	ASTExtraGameMode_OnGameEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.StopSyncSound
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                  pSouceActor                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameplayStatics::StopSyncSound(class AActor* pSouceActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.StopSyncSound");

	USTExtraGameplayStatics_StopSyncSound_Params params;
	params.pSouceActor = pSouceActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.STApplyPointDamage
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class AActor*                  DamagedActor                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 HitFromDirection               (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FHitResult              HitInfo                        (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// class AController*             EventInstigator                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  DamageTypeClass                (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraGameplayStatics::STApplyPointDamage(class AActor* DamagedActor, float BaseDamage, const struct FVector& HitFromDirection, const struct FHitResult& HitInfo, class AController* EventInstigator, class AActor* DamageCauser, class UClass* DamageTypeClass)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.STApplyPointDamage");

	USTExtraGameplayStatics_STApplyPointDamage_Params params;
	params.DamagedActor = DamagedActor;
	params.BaseDamage = BaseDamage;
	params.HitFromDirection = HitFromDirection;
	params.HitInfo = HitInfo;
	params.EventInstigator = EventInstigator;
	params.DamageCauser = DamageCauser;
	params.DamageTypeClass = DamageTypeClass;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.SetWetness
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                          Wetness                        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameplayStatics::SetWetness(float Wetness)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.SetWetness");

	USTExtraGameplayStatics_SetWetness_Params params;
	params.Wetness = Wetness;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.SetScreenSizeModifier
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// bool                           bActive                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               Center                         (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          Radius                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ScreenSizeFactor               (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameplayStatics::SetScreenSizeModifier(bool bActive, const struct FVector2D& Center, float Radius, float ScreenSizeFactor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.SetScreenSizeModifier");

	USTExtraGameplayStatics_SetScreenSizeModifier_Params params;
	params.bActive = bActive;
	params.Center = Center;
	params.Radius = Radius;
	params.ScreenSizeFactor = ScreenSizeFactor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.PostSyncAkEvent
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// int                            AkEventID                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  pSouceActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 AkLocation                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// bool                           IsFireSound                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraGameplayStatics::PostSyncAkEvent(int AkEventID, class AActor* pSouceActor, const struct FVector& AkLocation, bool IsFireSound)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.PostSyncAkEvent");

	USTExtraGameplayStatics_PostSyncAkEvent_Params params;
	params.AkEventID = AkEventID;
	params.pSouceActor = pSouceActor;
	params.AkLocation = AkLocation;
	params.IsFireSound = IsFireSound;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.IsPlayerPawnOverlappedThunderBall
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   PlayerPawn                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          ThunderBallRadius              (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraGameplayStatics::IsPlayerPawnOverlappedThunderBall(class ASTExtraBaseCharacter* PlayerPawn, float ThunderBallRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.IsPlayerPawnOverlappedThunderBall");

	USTExtraGameplayStatics_IsPlayerPawnOverlappedThunderBall_Params params;
	params.PlayerPawn = PlayerPawn;
	params.ThunderBallRadius = ThunderBallRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGameplayStatics.GetAllPlayerPawnsOfClass
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class UClass*                  PawnClass                      (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class APawn*>           OutPawns                       (Parm, OutParm, ZeroConstructor)

void USTExtraGameplayStatics::GetAllPlayerPawnsOfClass(class UObject* WorldContextObject, class UClass* PawnClass, TArray<class APawn*>* OutPawns)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGameplayStatics.GetAllPlayerPawnsOfClass");

	USTExtraGameplayStatics_GetAllPlayerPawnsOfClass_Params params;
	params.WorldContextObject = WorldContextObject;
	params.PawnClass = PawnClass;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutPawns != nullptr)
		*OutPawns = params.OutPawns;
}


// Function ShadowTrackerExtra.STExtraGlobalData.STExtraGlobalDataInstance
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USTExtraGlobalData*      ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USTExtraGlobalData* USTExtraGlobalData::STExtraGlobalDataInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGlobalData.STExtraGlobalDataInstance");

	USTExtraGlobalData_STExtraGlobalDataInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraGlobalData.CurVersionNumber
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraGlobalData::CurVersionNumber()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraGlobalData.CurVersionNumber");

	USTExtraGlobalData_CurVersionNumber_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraInputInterface.MoveUp
// (Native, Public)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraInputInterface::MoveUp(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraInputInterface.MoveUp");

	USTExtraInputInterface_MoveUp_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraInputInterface.MoveRight
// (Native, Public)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraInputInterface::MoveRight(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraInputInterface.MoveRight");

	USTExtraInputInterface_MoveRight_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraInputInterface.MoveForward
// (Native, Public)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraInputInterface::MoveForward(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraInputInterface.MoveForward");

	USTExtraInputInterface_MoveForward_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.UnequipWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraLobbyCharacter::UnequipWeapon(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.UnequipWeapon");

	ASTExtraLobbyCharacter_UnequipWeapon_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.SetLobbyPosIndexInAvatarScene
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            pos                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraLobbyCharacter::SetLobbyPosIndexInAvatarScene(int pos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.SetLobbyPosIndexInAvatarScene");

	ASTExtraLobbyCharacter_SetLobbyPosIndexInAvatarScene_Params params;
	params.pos = pos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.SetLobbyPosIndex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ELobbyCharacterPosIndex> pos                            (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraLobbyCharacter::SetLobbyPosIndex(TEnumAsByte<ELobbyCharacterPosIndex> pos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.SetLobbyPosIndex");

	ASTExtraLobbyCharacter_SetLobbyPosIndex_Params params;
	params.pos = pos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.PlayEmoteSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraLobbyCharacter::PlayEmoteSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.PlayEmoteSound");

	ASTExtraLobbyCharacter_PlayEmoteSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.PlayEmoteInterruptSound
// (Final, Native, Public, BlueprintCallable)

void ASTExtraLobbyCharacter::PlayEmoteInterruptSound()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.PlayEmoteInterruptSound");

	ASTExtraLobbyCharacter_PlayEmoteInterruptSound_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.OnPlayEmote
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            EmoteId                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraLobbyCharacter::OnPlayEmote(int EmoteId)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.OnPlayEmote");

	ASTExtraLobbyCharacter_OnPlayEmote_Params params;
	params.EmoteId = EmoteId;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.OnAsyncLoadEmoteAnimList
// (Final, Native, Public)

void ASTExtraLobbyCharacter::OnAsyncLoadEmoteAnimList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.OnAsyncLoadEmoteAnimList");

	ASTExtraLobbyCharacter_OnAsyncLoadEmoteAnimList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.OnAsyncLoadEmoteAnim
// (Final, Native, Public)

void ASTExtraLobbyCharacter::OnAsyncLoadEmoteAnim()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.OnAsyncLoadEmoteAnim");

	ASTExtraLobbyCharacter_OnAsyncLoadEmoteAnim_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.LoadAnimSoftPtrListFromIndex
// (Final, Native, Public)

void ASTExtraLobbyCharacter::LoadAnimSoftPtrListFromIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.LoadAnimSoftPtrListFromIndex");

	ASTExtraLobbyCharacter_LoadAnimSoftPtrListFromIndex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.LoadAnimSoftPtrFromIndex
// (Final, Native, Public)
// Parameters:
// int                            Index                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraLobbyCharacter::LoadAnimSoftPtrFromIndex(int Index)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.LoadAnimSoftPtrFromIndex");

	ASTExtraLobbyCharacter_LoadAnimSoftPtrFromIndex_Params params;
	params.Index = Index;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.HandleOnCharAnimLoadingFinished
// (Final, Native, Public)

void ASTExtraLobbyCharacter::HandleOnCharAnimLoadingFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.HandleOnCharAnimLoadingFinished");

	ASTExtraLobbyCharacter_HandleOnCharAnimLoadingFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetWeaponAnimComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UAELobbyCharAnimListComp* ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UAELobbyCharAnimListComp* ASTExtraLobbyCharacter::GetWeaponAnimComponent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetWeaponAnimComponent");

	ASTExtraLobbyCharacter_GetWeaponAnimComponent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetWeaponAnimByAnimTypeAndPosType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ECharacterAnimType> AnimType                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterPoseType> PoseType                       (Parm, ZeroConstructor, IsPlainOldData)
// class UAnimationAsset*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UAnimationAsset* ASTExtraLobbyCharacter::GetWeaponAnimByAnimTypeAndPosType(TEnumAsByte<ECharacterAnimType> AnimType, TEnumAsByte<ECharacterPoseType> PoseType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetWeaponAnimByAnimTypeAndPosType");

	ASTExtraLobbyCharacter_GetWeaponAnimByAnimTypeAndPosType_Params params;
	params.AnimType = AnimType;
	params.PoseType = PoseType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetLobbyPosIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ELobbyCharacterPosIndex> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<ELobbyCharacterPosIndex> ASTExtraLobbyCharacter::GetLobbyPosIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetLobbyPosIndex");

	ASTExtraLobbyCharacter_GetLobbyPosIndex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetEmoteHandle
// (Event, Public, BlueprintEvent)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackEmoteHandle*    ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBackpackEmoteHandle* ASTExtraLobbyCharacter::GetEmoteHandle(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetEmoteHandle");

	ASTExtraLobbyCharacter_GetEmoteHandle_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCurrentWeapon
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraWeapon*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraWeapon* ASTExtraLobbyCharacter::GetCurrentWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCurrentWeapon");

	ASTExtraLobbyCharacter_GetCurrentWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCurrentEmoteId
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int ASTExtraLobbyCharacter::GetCurrentEmoteId()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCurrentEmoteId");

	ASTExtraLobbyCharacter_GetCurrentEmoteId_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCharacterAnimByAnimTypeAndPosType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TEnumAsByte<ECharacterAnimType> AnimType                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ECharacterPoseType> PoseType                       (Parm, ZeroConstructor, IsPlainOldData)
// class UAnimationAsset*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UAnimationAsset* ASTExtraLobbyCharacter::GetCharacterAnimByAnimTypeAndPosType(TEnumAsByte<ECharacterAnimType> AnimType, TEnumAsByte<ECharacterPoseType> PoseType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.GetCharacterAnimByAnimTypeAndPosType");

	ASTExtraLobbyCharacter_GetCharacterAnimByAnimTypeAndPosType_Params params;
	params.AnimType = AnimType;
	params.PoseType = PoseType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.EquipWeapon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraLobbyCharacter::EquipWeapon(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.EquipWeapon");

	ASTExtraLobbyCharacter_EquipWeapon_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraLobbyCharacter.EmoteAnimFinishedSuccessfully
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraLobbyCharacter::EmoteAnimFinishedSuccessfully()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraLobbyCharacter.EmoteAnimFinishedSuccessfully");

	ASTExtraLobbyCharacter_EmoteAnimFinishedSuccessfully_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.UpdateTeamMateLocAndRot
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<class ASTExtraPlayerState*> TeamMateStateArray             (Parm, ZeroConstructor)
// TArray<class UPanelWidget*>    TeamMateInfoGridArray          (ConstParm, Parm, ZeroConstructor)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          CorrectMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerState*     myPS                           (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UImage*>          ArrowImageArray                (Parm, ZeroConstructor)
// struct FVector2D               MapAdjustOffset                (Parm, IsPlainOldData)
// float                          MapWindowHalfExtent            (Parm, ZeroConstructor, IsPlainOldData)
// TArray<int>                    OutOfRangeTeammateIndex        (Parm, OutParm, ZeroConstructor)
// bool                           isEntireMap                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::UpdateTeamMateLocAndRot(TArray<class ASTExtraPlayerState*> TeamMateStateArray, TArray<class UPanelWidget*> TeamMateInfoGridArray, const struct FVector& LevelLandscapeCenter, float CorrectMapScale, float RotateAngle, class ASTExtraPlayerState* myPS, TArray<class UImage*> ArrowImageArray, const struct FVector2D& MapAdjustOffset, float MapWindowHalfExtent, bool isEntireMap, TArray<int>* OutOfRangeTeammateIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.UpdateTeamMateLocAndRot");

	USTExtraMapFunctionLibrary_UpdateTeamMateLocAndRot_Params params;
	params.TeamMateStateArray = TeamMateStateArray;
	params.TeamMateInfoGridArray = TeamMateInfoGridArray;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.CorrectMapScale = CorrectMapScale;
	params.RotateAngle = RotateAngle;
	params.myPS = myPS;
	params.ArrowImageArray = ArrowImageArray;
	params.MapAdjustOffset = MapAdjustOffset;
	params.MapWindowHalfExtent = MapWindowHalfExtent;
	params.isEntireMap = isEntireMap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutOfRangeTeammateIndex != nullptr)
		*OutOfRangeTeammateIndex = params.OutOfRangeTeammateIndex;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.UpdatePlayersLocAndRot
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<class ASTExtraPlayerState*> TeamMateStateArray             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// TArray<class UWidget*>         PlayerInfoWidgetArray          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 LevelLandscapeCenter           (ConstParm, Parm, IsPlainOldData)
// float                          CorrectMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerState*     myPS                           (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UWidget*>         PlayerRotWidgetArray           (Parm, ZeroConstructor)
// struct FVector2D               MapAdjustOffset                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          MapWindowHalfExtent            (Parm, ZeroConstructor, IsPlainOldData)
// TArray<int>                    OutOfRangeTeammateIndex        (Parm, OutParm, ZeroConstructor)
// bool                           isEntireMap                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::UpdatePlayersLocAndRot(TArray<class ASTExtraPlayerState*> TeamMateStateArray, TArray<class UWidget*> PlayerInfoWidgetArray, const struct FVector& LevelLandscapeCenter, float CorrectMapScale, float RotateAngle, class ASTExtraPlayerState* myPS, TArray<class UWidget*> PlayerRotWidgetArray, const struct FVector2D& MapAdjustOffset, float MapWindowHalfExtent, bool isEntireMap, TArray<int>* OutOfRangeTeammateIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.UpdatePlayersLocAndRot");

	USTExtraMapFunctionLibrary_UpdatePlayersLocAndRot_Params params;
	params.TeamMateStateArray = TeamMateStateArray;
	params.PlayerInfoWidgetArray = PlayerInfoWidgetArray;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.CorrectMapScale = CorrectMapScale;
	params.RotateAngle = RotateAngle;
	params.myPS = myPS;
	params.PlayerRotWidgetArray = PlayerRotWidgetArray;
	params.MapAdjustOffset = MapAdjustOffset;
	params.MapWindowHalfExtent = MapWindowHalfExtent;
	params.isEntireMap = isEntireMap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutOfRangeTeammateIndex != nullptr)
		*OutOfRangeTeammateIndex = params.OutOfRangeTeammateIndex;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.SetLeftRouteLength
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UCanvasPanelSlot*        LeftRouteSlot                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UCanvasPanelSlot*        PassedRouteSlot                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// float                          FlyingProcess                  (Parm, ZeroConstructor, IsPlainOldData)
// float                          RouteTotalLengthInMap          (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapScale                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          TopOffset                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          BottomOffset                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bIsWar                         (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::SetLeftRouteLength(class UCanvasPanelSlot* LeftRouteSlot, class UCanvasPanelSlot* PassedRouteSlot, float FlyingProcess, float RouteTotalLengthInMap, float MapScale, float TopOffset, float BottomOffset, bool bIsWar)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.SetLeftRouteLength");

	USTExtraMapFunctionLibrary_SetLeftRouteLength_Params params;
	params.LeftRouteSlot = LeftRouteSlot;
	params.PassedRouteSlot = PassedRouteSlot;
	params.FlyingProcess = FlyingProcess;
	params.RouteTotalLengthInMap = RouteTotalLengthInMap;
	params.MapScale = MapScale;
	params.TopOffset = TopOffset;
	params.BottomOffset = BottomOffset;
	params.bIsWar = bIsWar;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.RnederThreadSetBigCore
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                           isbig                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::RnederThreadSetBigCore(bool isbig)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.RnederThreadSetBigCore");

	USTExtraMapFunctionLibrary_RnederThreadSetBigCore_Params params;
	params.isbig = isbig;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.MapFuncLibInstance
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class USTExtraMapFunctionLibrary* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USTExtraMapFunctionLibrary* USTExtraMapFunctionLibrary::MapFuncLibInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.MapFuncLibInstance");

	USTExtraMapFunctionLibrary_MapFuncLibInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.MapCenterToPointVector
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                 PointLocationInLevel           (Parm, IsPlainOldData)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          LevelToMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector USTExtraMapFunctionLibrary::MapCenterToPointVector(const struct FVector& PointLocationInLevel, const struct FVector& LevelLandscapeCenter, float LevelToMapScale)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.MapCenterToPointVector");

	USTExtraMapFunctionLibrary_MapCenterToPointVector_Params params;
	params.PointLocationInLevel = PointLocationInLevel;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.LevelToMapScale = LevelToMapScale;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.IsPlayerOutSafeZone
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraGameStateBase*   GS                             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraMapFunctionLibrary::IsPlayerOutSafeZone(class APlayerController* PC, class ASTExtraGameStateBase* GS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.IsPlayerOutSafeZone");

	USTExtraMapFunctionLibrary_IsPlayerOutSafeZone_Params params;
	params.PC = PC;
	params.GS = GS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.IsNeedDrawGuideLine
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          WhiteCircleRadius              (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// struct FVector2D               WhiteCircleCoord               (Parm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraMapFunctionLibrary::IsNeedDrawGuideLine(float WhiteCircleRadius, const struct FVector2D& PlayerCoord, const struct FVector2D& WhiteCircleCoord)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.IsNeedDrawGuideLine");

	USTExtraMapFunctionLibrary_IsNeedDrawGuideLine_Params params;
	params.WhiteCircleRadius = WhiteCircleRadius;
	params.PlayerCoord = PlayerCoord;
	params.WhiteCircleCoord = WhiteCircleCoord;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetRotatedVector2D
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D               InputVector                    (Parm, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D USTExtraMapFunctionLibrary::GetRotatedVector2D(const struct FVector2D& InputVector, float RotateAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetRotatedVector2D");

	USTExtraMapFunctionLibrary_GetRotatedVector2D_Params params;
	params.InputVector = InputVector;
	params.RotateAngle = RotateAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetMapStandardPoint
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AMiniMapStandardPoint*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AMiniMapStandardPoint* USTExtraMapFunctionLibrary::GetMapStandardPoint(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetMapStandardPoint");

	USTExtraMapFunctionLibrary_GetMapStandardPoint_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetMapRealTimeInfo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraGameStateBase*   GS                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          LevelToMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FMapRealTimeInfo        CacheMapInfo                   (Parm)
// bool                           isEntireMap                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FMapRealTimeInfo        ReturnValue                    (Parm, OutParm, ReturnParm)

struct FMapRealTimeInfo USTExtraMapFunctionLibrary::GetMapRealTimeInfo(class ASTExtraPlayerController* PC, class ASTExtraGameStateBase* GS, const struct FVector& LevelLandscapeCenter, float LevelToMapScale, float RotateAngle, const struct FMapRealTimeInfo& CacheMapInfo, bool isEntireMap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetMapRealTimeInfo");

	USTExtraMapFunctionLibrary_GetMapRealTimeInfo_Params params;
	params.PC = PC;
	params.GS = GS;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.LevelToMapScale = LevelToMapScale;
	params.RotateAngle = RotateAngle;
	params.CacheMapInfo = CacheMapInfo;
	params.isEntireMap = isEntireMap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetLevelLandscapeBounds
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraMapFunctionLibrary::GetLevelLandscapeBounds(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetLevelLandscapeBounds");

	USTExtraMapFunctionLibrary_GetLevelLandscapeBounds_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetLandscapeMidPoint
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D USTExtraMapFunctionLibrary::GetLandscapeMidPoint(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetLandscapeMidPoint");

	USTExtraMapFunctionLibrary_GetLandscapeMidPoint_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetCircleMapLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 CirclePositionInWorld          (Parm, IsPlainOldData)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          LevelToMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D USTExtraMapFunctionLibrary::GetCircleMapLocation(const struct FVector& CirclePositionInWorld, const struct FVector& LevelLandscapeCenter, float LevelToMapScale, float RotateAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetCircleMapLocation");

	USTExtraMapFunctionLibrary_GetCircleMapLocation_Params params;
	params.CirclePositionInWorld = CirclePositionInWorld;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.LevelToMapScale = LevelToMapScale;
	params.RotateAngle = RotateAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetAlivePlayerNumber
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int USTExtraMapFunctionLibrary::GetAlivePlayerNumber()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GetAlivePlayerNumber");

	USTExtraMapFunctionLibrary_GetAlivePlayerNumber_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GameThreadSetBigCore
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// bool                           isbig                          (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::GameThreadSetBigCore(bool isbig)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.GameThreadSetBigCore");

	USTExtraMapFunctionLibrary_GameThreadSetBigCore_Params params;
	params.isbig = isbig;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.FindPointInWhichLandscape
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 TargetPoint                    (Parm, IsPlainOldData)
// class UObject*                 ContextObject                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D USTExtraMapFunctionLibrary::FindPointInWhichLandscape(const struct FVector& TargetPoint, class UObject* ContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.FindPointInWhichLandscape");

	USTExtraMapFunctionLibrary_FindPointInWhichLandscape_Params params;
	params.TargetPoint = TargetPoint;
	params.ContextObject = ContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerMarkerInGrid
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class UGridSlot*               PlayerMarkerPanelSlot          (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// class UPanelWidget*            PlayerMarkerImagePanel         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// TEnumAsByte<EPlayerOperation>  PlayerOperation                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawPlayerMarkerInGrid(class ASTExtraPlayerController* PC, class UGridSlot* PlayerMarkerPanelSlot, const struct FVector2D& PlayerCoord, class UPanelWidget* PlayerMarkerImagePanel, TEnumAsByte<EPlayerOperation> PlayerOperation, float RotateAngle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerMarkerInGrid");

	USTExtraMapFunctionLibrary_DrawPlayerMarkerInGrid_Params params;
	params.PC = PC;
	params.PlayerMarkerPanelSlot = PlayerMarkerPanelSlot;
	params.PlayerCoord = PlayerCoord;
	params.PlayerMarkerImagePanel = PlayerMarkerImagePanel;
	params.PlayerOperation = PlayerOperation;
	params.RotateAngle = RotateAngle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerMarker
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class UPanelWidget*            PlayerMarkerPanel              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// TEnumAsByte<EPlayerOperation>  PlayerOperation                (Parm, ZeroConstructor, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// class UPanelWidget*            selfArrow                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           isEntireMap                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawPlayerMarker(class ASTExtraPlayerController* PC, class UPanelWidget* PlayerMarkerPanel, const struct FVector2D& PlayerCoord, TEnumAsByte<EPlayerOperation> PlayerOperation, float RotateAngle, class UPanelWidget* selfArrow, bool isEntireMap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerMarker");

	USTExtraMapFunctionLibrary_DrawPlayerMarker_Params params;
	params.PC = PC;
	params.PlayerMarkerPanel = PlayerMarkerPanel;
	params.PlayerCoord = PlayerCoord;
	params.PlayerOperation = PlayerOperation;
	params.RotateAngle = RotateAngle;
	params.selfArrow = selfArrow;
	params.isEntireMap = isEntireMap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerItineraryInMap
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPaintContext           InContext                      (ConstParm, Parm, OutParm, ReferenceParm)
// TArray<struct FVector>         PlayerPosList                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector2D               MapSize                        (Parm, IsPlainOldData)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          LevelToMapScale                (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            LineColor                      (Parm, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawPlayerItineraryInMap(const struct FPaintContext& InContext, TArray<struct FVector> PlayerPosList, const struct FVector2D& MapSize, const struct FVector& LevelLandscapeCenter, float LevelToMapScale, const struct FLinearColor& LineColor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawPlayerItineraryInMap");

	USTExtraMapFunctionLibrary_DrawPlayerItineraryInMap_Params params;
	params.InContext = InContext;
	params.PlayerPosList = PlayerPosList;
	params.MapSize = MapSize;
	params.LevelLandscapeCenter = LevelLandscapeCenter;
	params.LevelToMapScale = LevelToMapScale;
	params.LineColor = LineColor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawGuideLine
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPaintContext           InContext                      (ConstParm, Parm, OutParm, ReferenceParm)
// float                          DashSize                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DashColor                      (Parm, IsPlainOldData)
// float                          MapWindowExtent                (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapImageExtent                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               WhiteCircleCenter              (Parm, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// TEnumAsByte<EMapType>          MapType                        (Parm, ZeroConstructor, IsPlainOldData)
// float                          LineThickness                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAntiAlias                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawGuideLine(const struct FPaintContext& InContext, float DashSize, const struct FLinearColor& DashColor, float MapWindowExtent, float MapImageExtent, const struct FVector2D& WhiteCircleCenter, const struct FVector2D& PlayerCoord, TEnumAsByte<EMapType> MapType, float LineThickness, bool bAntiAlias)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawGuideLine");

	USTExtraMapFunctionLibrary_DrawGuideLine_Params params;
	params.InContext = InContext;
	params.DashSize = DashSize;
	params.DashColor = DashColor;
	params.MapWindowExtent = MapWindowExtent;
	params.MapImageExtent = MapImageExtent;
	params.WhiteCircleCenter = WhiteCircleCenter;
	params.PlayerCoord = PlayerCoord;
	params.MapType = MapType;
	params.LineThickness = LineThickness;
	params.bAntiAlias = bAntiAlias;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawCircle
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPaintContext           InContext                      (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector2D               CircleCenter                   (Parm, IsPlainOldData)
// struct FLinearColor            CircleColor                    (Parm, IsPlainOldData)
// float                          CircleRadius                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapWindowExtent                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// TEnumAsByte<EMapType>          MapType                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAntiAlias                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawCircle(const struct FPaintContext& InContext, const struct FVector2D& CircleCenter, const struct FLinearColor& CircleColor, float CircleRadius, float MapWindowExtent, const struct FVector2D& PlayerCoord, TEnumAsByte<EMapType> MapType, bool bAntiAlias)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawCircle");

	USTExtraMapFunctionLibrary_DrawCircle_Params params;
	params.InContext = InContext;
	params.CircleCenter = CircleCenter;
	params.CircleColor = CircleColor;
	params.CircleRadius = CircleRadius;
	params.MapWindowExtent = MapWindowExtent;
	params.PlayerCoord = PlayerCoord;
	params.MapType = MapType;
	params.bAntiAlias = bAntiAlias;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawAirplaneRouteInMiniMap
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPaintContext           InContext                      (ConstParm, Parm, OutParm, ReferenceParm)
// float                          DashSize                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DashColor                      (Parm, IsPlainOldData)
// float                          MapWindowExtent                (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapImageExtent                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 MapCenterToPlayer              (Parm, IsPlainOldData)
// struct FVector2D               EndCoord                       (Parm, IsPlainOldData)
// struct FVector2D               PlayerCoord                    (Parm, IsPlainOldData)
// struct FVector2D               RouteVelocity                  (Parm, IsPlainOldData)
// float                          LineThickness                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAntiAlias                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawAirplaneRouteInMiniMap(const struct FPaintContext& InContext, float DashSize, const struct FLinearColor& DashColor, float MapWindowExtent, float MapImageExtent, const struct FVector& MapCenterToPlayer, const struct FVector2D& EndCoord, const struct FVector2D& PlayerCoord, const struct FVector2D& RouteVelocity, float LineThickness, bool bAntiAlias)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawAirplaneRouteInMiniMap");

	USTExtraMapFunctionLibrary_DrawAirplaneRouteInMiniMap_Params params;
	params.InContext = InContext;
	params.DashSize = DashSize;
	params.DashColor = DashColor;
	params.MapWindowExtent = MapWindowExtent;
	params.MapImageExtent = MapImageExtent;
	params.MapCenterToPlayer = MapCenterToPlayer;
	params.EndCoord = EndCoord;
	params.PlayerCoord = PlayerCoord;
	params.RouteVelocity = RouteVelocity;
	params.LineThickness = LineThickness;
	params.bAntiAlias = bAntiAlias;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawAirplaneRouteInEntiremap
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// struct FPaintContext           InContext                      (ConstParm, Parm, OutParm, ReferenceParm)
// float                          DashSize                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FLinearColor            DashColor                      (Parm, IsPlainOldData)
// float                          MapWindowExtent                (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapImageExtent                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          MiniMapWindowExtent            (Parm, ZeroConstructor, IsPlainOldData)
// float                          MiniMapImageExtent             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 MapCenterToPlayer              (Parm, IsPlainOldData)
// struct FVector2D               StartCoord                     (Parm, IsPlainOldData)
// struct FVector2D               EndCoord                       (Parm, IsPlainOldData)
// float                          LineThickness                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAntiAlias                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::DrawAirplaneRouteInEntiremap(const struct FPaintContext& InContext, float DashSize, const struct FLinearColor& DashColor, float MapWindowExtent, float MapImageExtent, float MiniMapWindowExtent, float MiniMapImageExtent, const struct FVector& MapCenterToPlayer, const struct FVector2D& StartCoord, const struct FVector2D& EndCoord, float LineThickness, bool bAntiAlias)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.DrawAirplaneRouteInEntiremap");

	USTExtraMapFunctionLibrary_DrawAirplaneRouteInEntiremap_Params params;
	params.InContext = InContext;
	params.DashSize = DashSize;
	params.DashColor = DashColor;
	params.MapWindowExtent = MapWindowExtent;
	params.MapImageExtent = MapImageExtent;
	params.MiniMapWindowExtent = MiniMapWindowExtent;
	params.MiniMapImageExtent = MiniMapImageExtent;
	params.MapCenterToPlayer = MapCenterToPlayer;
	params.StartCoord = StartCoord;
	params.EndCoord = EndCoord;
	params.LineThickness = LineThickness;
	params.bAntiAlias = bAntiAlias;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerToMarkerDist
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)
// float                          LevelLandscapeExtent           (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               MarkerInMap                    (Parm, IsPlainOldData)
// struct FVector                 LevelLandscapeCenter           (Parm, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraMapFunctionLibrary::CalPlayerToMarkerDist(class APlayerController* PC, float LevelLandscapeExtent, const struct FVector2D& MarkerInMap, const struct FVector& LevelLandscapeCenter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerToMarkerDist");

	USTExtraMapFunctionLibrary_CalPlayerToMarkerDist_Params params;
	params.PC = PC;
	params.LevelLandscapeExtent = LevelLandscapeExtent;
	params.MarkerInMap = MarkerInMap;
	params.LevelLandscapeCenter = LevelLandscapeCenter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerToMarkerDelYawAndDist
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 MarkerAlign                    (Parm, IsPlainOldData)
// float                          LevelLandscapeExtent           (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 LandscapeCenter                (Parm, IsPlainOldData)
// float                          DelYaw                         (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          Dist                           (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void USTExtraMapFunctionLibrary::CalPlayerToMarkerDelYawAndDist(class APlayerController* PC, const struct FVector& MarkerAlign, float LevelLandscapeExtent, const struct FVector& LandscapeCenter, float* DelYaw, float* Dist)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerToMarkerDelYawAndDist");

	USTExtraMapFunctionLibrary_CalPlayerToMarkerDelYawAndDist_Params params;
	params.PC = PC;
	params.MarkerAlign = MarkerAlign;
	params.LevelLandscapeExtent = LevelLandscapeExtent;
	params.LandscapeCenter = LandscapeCenter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (DelYaw != nullptr)
		*DelYaw = params.DelYaw;
	if (Dist != nullptr)
		*Dist = params.Dist;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerRotationToPointDelYaw
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 TargetPoint                    (Parm, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float USTExtraMapFunctionLibrary::CalPlayerRotationToPointDelYaw(class APlayerController* PC, const struct FVector& TargetPoint)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.CalPlayerRotationToPointDelYaw");

	USTExtraMapFunctionLibrary_CalPlayerRotationToPointDelYaw_Params params;
	params.PC = PC;
	params.TargetPoint = TargetPoint;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraMapFunctionLibrary.AdjustMapPosition
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UCanvasPanelSlot*        MapCanvas                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector2D               MapCenterToPlayer              (Parm, IsPlainOldData)
// float                          RotateAngle                    (Parm, ZeroConstructor, IsPlainOldData)
// float                          MiniMapWindowHalfSize          (Parm, ZeroConstructor, IsPlainOldData)
// float                          MapImageSize                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector2D USTExtraMapFunctionLibrary::AdjustMapPosition(class UCanvasPanelSlot* MapCanvas, const struct FVector2D& MapCenterToPlayer, float RotateAngle, float MiniMapWindowHalfSize, float MapImageSize)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraMapFunctionLibrary.AdjustMapPosition");

	USTExtraMapFunctionLibrary_AdjustMapPosition_Params params;
	params.MapCanvas = MapCanvas;
	params.MapCenterToPlayer = MapCenterToPlayer;
	params.RotateAngle = RotateAngle;
	params.MiniMapWindowHalfSize = MiniMapWindowHalfSize;
	params.MapImageSize = MapImageSize;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.UpdateParachuteFallingCameraDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          alpha                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::UpdateParachuteFallingCameraDistance(float alpha)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.UpdateParachuteFallingCameraDistance");

	ASTExtraPlayerCharacter_UpdateParachuteFallingCameraDistance_Params params;
	params.alpha = alpha;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.UpdateIndoorState
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           isIndoor                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::UpdateIndoorState(bool isIndoor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.UpdateIndoorState");

	ASTExtraPlayerCharacter_UpdateIndoorState_Params params;
	params.isIndoor = isIndoor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.TouchCancelSkillLock
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerCharacter::TouchCancelSkillLock()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.TouchCancelSkillLock");

	ASTExtraPlayerCharacter_TouchCancelSkillLock_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SyncDeadTombBoxToController
// (Native, Public)
// Parameters:
// class APlayerTombBox*          _DeadTombBox                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SyncDeadTombBoxToController(class APlayerTombBox* _DeadTombBox)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SyncDeadTombBoxToController");

	ASTExtraPlayerCharacter_SyncDeadTombBoxToController_Params params;
	params._DeadTombBox = _DeadTombBox;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToParachuteOpening
// (Native, Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::SwitchCameraToParachuteOpening()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToParachuteOpening");

	ASTExtraPlayerCharacter_SwitchCameraToParachuteOpening_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToParachuteFalling
// (Native, Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::SwitchCameraToParachuteFalling()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToParachuteFalling");

	ASTExtraPlayerCharacter_SwitchCameraToParachuteFalling_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToNormal
// (Native, Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::SwitchCameraToNormal()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraToNormal");

	ASTExtraPlayerCharacter_SwitchCameraToNormal_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPUpdate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          alpha                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SwitchCameraFromParachuteOpeningToTPPUpdate(float alpha)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPUpdate");

	ASTExtraPlayerCharacter_SwitchCameraFromParachuteOpeningToTPPUpdate_Params params;
	params.alpha = alpha;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPStop
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::SwitchCameraFromParachuteOpeningToTPPStop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPStop");

	ASTExtraPlayerCharacter_SwitchCameraFromParachuteOpeningToTPPStop_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPFinish
// (Final, Native, Public, BlueprintCallable)

void ASTExtraPlayerCharacter::SwitchCameraFromParachuteOpeningToTPPFinish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPFinish");

	ASTExtraPlayerCharacter_SwitchCameraFromParachuteOpeningToTPPFinish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPBeginPlay
// (Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::SwitchCameraFromParachuteOpeningToTPPBeginPlay()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SwitchCameraFromParachuteOpeningToTPPBeginPlay");

	ASTExtraPlayerCharacter_SwitchCameraFromParachuteOpeningToTPPBeginPlay_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.StopCamShake
// (Native, Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::StopCamShake()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.StopCamShake");

	ASTExtraPlayerCharacter_StopCamShake_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.StartUpdatingParachuteFallingCameraDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            nearPlaneDistance              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::StartUpdatingParachuteFallingCameraDistance(int nearPlaneDistance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.StartUpdatingParachuteFallingCameraDistance");

	ASTExtraPlayerCharacter_StartUpdatingParachuteFallingCameraDistance_Params params;
	params.nearPlaneDistance = nearPlaneDistance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.StartCamShake
// (Native, Event, Public, BlueprintEvent)

void ASTExtraPlayerCharacter::StartCamShake()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.StartCamShake");

	ASTExtraPlayerCharacter_StartCamShake_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ShowNightVisionFrame
// (Native, Public, BlueprintCallable)

void ASTExtraPlayerCharacter::ShowNightVisionFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ShowNightVisionFrame");

	ASTExtraPlayerCharacter_ShowNightVisionFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ShouldTriggerEntryEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EUTSkillEntry                  EntryEvent                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerCharacter::ShouldTriggerEntryEvent(EUTSkillEntry EntryEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ShouldTriggerEntryEvent");

	ASTExtraPlayerCharacter_ShouldTriggerEntryEvent_Params params;
	params.EntryEvent = EntryEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ShouldDropBagItem
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FItemDefineID           SkillItemID                    (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerCharacter::ShouldDropBagItem(const struct FItemDefineID& SkillItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ShouldDropBagItem");

	ASTExtraPlayerCharacter_ShouldDropBagItem_Params params;
	params.SkillItemID = SkillItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SetSwimRotateX_Ex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          NewSwimRotateX                 (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SetSwimRotateX_Ex(float NewSwimRotateX)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SetSwimRotateX_Ex");

	ASTExtraPlayerCharacter_SetSwimRotateX_Ex_Params params;
	params.NewSwimRotateX = NewSwimRotateX;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SetRainyEffectParam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          InRainyEffectParam             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SetRainyEffectParam(TEnumAsByte<EScreenParticleEffectType> EffectType, float InRainyEffectParam)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SetRainyEffectParam");

	ASTExtraPlayerCharacter_SetRainyEffectParam_Params params;
	params.EffectType = EffectType;
	params.InRainyEffectParam = InRainyEffectParam;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SetRainyEffectEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           InEnable                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          InRainyEffectParam             (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SetRainyEffectEnable(TEnumAsByte<EScreenParticleEffectType> EffectType, bool InEnable, float InRainyEffectParam)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SetRainyEffectEnable");

	ASTExtraPlayerCharacter_SetRainyEffectEnable_Params params;
	params.EffectType = EffectType;
	params.InEnable = InEnable;
	params.InRainyEffectParam = InRainyEffectParam;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SetPitchViewAngle
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                          MinPitch                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaxPitch                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SetPitchViewAngle(float MinPitch, float MaxPitch)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SetPitchViewAngle");

	ASTExtraPlayerCharacter_SetPitchViewAngle_Params params;
	params.MinPitch = MinPitch;
	params.MaxPitch = MaxPitch;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.SetParachuteState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EParachuteState>   State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::SetParachuteState(TEnumAsByte<EParachuteState> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.SetParachuteState");

	ASTExtraPlayerCharacter_SetParachuteState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ServerSetBulletFlySoundData
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults, NetValidate)
// Parameters:
// class ASTExtraPlayerCharacter* PlayerCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraShootWeapon*     InstigateWeapon                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 FlySoundPos                    (Parm, IsPlainOldData)

void ASTExtraPlayerCharacter::ServerSetBulletFlySoundData(class ASTExtraPlayerCharacter* PlayerCharacter, class ASTExtraShootWeapon* InstigateWeapon, const struct FVector& FlySoundPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ServerSetBulletFlySoundData");

	ASTExtraPlayerCharacter_ServerSetBulletFlySoundData_Params params;
	params.PlayerCharacter = PlayerCharacter;
	params.InstigateWeapon = InstigateWeapon;
	params.FlySoundPos = FlySoundPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ReleaseTrigger
// (Native, Public, BlueprintCallable)
// Parameters:
// EControllerHand                Hand                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::ReleaseTrigger(EControllerHand Hand)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ReleaseTrigger");

	ASTExtraPlayerCharacter_ReleaseTrigger_Params params;
	params.Hand = Hand;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.PushTrigger
// (Native, Public, BlueprintCallable)
// Parameters:
// EControllerHand                Hand                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::PushTrigger(EControllerHand Hand)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.PushTrigger");

	ASTExtraPlayerCharacter_PushTrigger_Params params;
	params.Hand = Hand;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ProneWithTerrain
// (Final, Native, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                CharacterRotation              (Parm, IsPlainOldData)
// bool                           isMoving                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          Offset                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          deap                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::ProneWithTerrain(const struct FRotator& CharacterRotation, bool isMoving, float Offset, float deap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ProneWithTerrain");

	ASTExtraPlayerCharacter_ProneWithTerrain_Params params;
	params.CharacterRotation = CharacterRotation;
	params.isMoving = isMoving;
	params.Offset = Offset;
	params.deap = deap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.PlayParticleInFrontOfCamera
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// struct FTransform              Offset                         (ConstParm, Parm, ReferenceParm, IsPlainOldData)
// struct FName                   AtachSocket                    (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData)
// class UParticleSystem*         ParticleTemplate               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::PlayParticleInFrontOfCamera(const struct FTransform& Offset, const struct FName& AtachSocket, class UParticleSystem* ParticleTemplate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.PlayParticleInFrontOfCamera");

	ASTExtraPlayerCharacter_PlayParticleInFrontOfCamera_Params params;
	params.Offset = Offset;
	params.AtachSocket = AtachSocket;
	params.ParticleTemplate = ParticleTemplate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ParachutePlaySound
// (Event, Public, BlueprintEvent)
// Parameters:
// class UAkAudioEvent*           LocalAkEvent                   (Parm, ZeroConstructor, IsPlainOldData)
// class UAkAudioEvent*           RemoteAkEvent                  (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::ParachutePlaySound(class UAkAudioEvent* LocalAkEvent, class UAkAudioEvent* RemoteAkEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ParachutePlaySound");

	ASTExtraPlayerCharacter_ParachutePlaySound_Params params;
	params.LocalAkEvent = LocalAkEvent;
	params.RemoteAkEvent = RemoteAkEvent;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnSkillFinishedDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// EUTSkillStopReason             StopReason                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            SkillID                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           HasThrownGrenade               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnSkillFinishedDelegate__DelegateSignature(EUTSkillStopReason StopReason, int SkillID, bool HasThrownGrenade)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnSkillFinishedDelegate__DelegateSignature");

	ASTExtraPlayerCharacter_OnSkillFinishedDelegate__DelegateSignature_Params params;
	params.StopReason = StopReason;
	params.SkillID = SkillID;
	params.HasThrownGrenade = HasThrownGrenade;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRep_STPlayerController
// (Final, Native, Public)

void ASTExtraPlayerCharacter::OnRep_STPlayerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRep_STPlayerController");

	ASTExtraPlayerCharacter_OnRep_STPlayerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRep_ParachuteState
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EParachuteState>   State                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnRep_ParachuteState(TEnumAsByte<EParachuteState> State)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRep_ParachuteState");

	ASTExtraPlayerCharacter_OnRep_ParachuteState_Params params;
	params.State = State;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRank
// (Final, Native, Public)
// Parameters:
// int                            Kills                          (Parm, ZeroConstructor, IsPlainOldData)
// int                            Rank                           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnRank(int Kills, int Rank)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.OnRank");

	ASTExtraPlayerCharacter_OnRank_Params params;
	params.Kills = Kills;
	params.Rank = Rank;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnHasTombBoxesAvailableChanged__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           bIsAvailable                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnHasTombBoxesAvailableChanged__DelegateSignature(bool bIsAvailable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnHasTombBoxesAvailableChanged__DelegateSignature");

	ASTExtraPlayerCharacter_OnHasTombBoxesAvailableChanged__DelegateSignature_Params params;
	params.bIsAvailable = bIsAvailable;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnHasPickupPropsAvailableChanged__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// bool                           bIsAvailable                   (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnHasPickupPropsAvailableChanged__DelegateSignature(bool bIsAvailable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraPlayerCharacter.OnHasPickupPropsAvailableChanged__DelegateSignature");

	ASTExtraPlayerCharacter_OnHasPickupPropsAvailableChanged__DelegateSignature_Params params;
	params.bIsAvailable = bIsAvailable;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.OnAvatarEquippedSucc
// (Final, Native, Protected)
// Parameters:
// EAvatarSlotType                slotType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isEquipped                     (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::OnAvatarEquippedSucc(EAvatarSlotType slotType, bool isEquipped)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.OnAvatarEquippedSucc");

	ASTExtraPlayerCharacter_OnAvatarEquippedSucc_Params params;
	params.slotType = slotType;
	params.isEquipped = isEquipped;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.IsGrenadeEmpty
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraPlayerCharacter::IsGrenadeEmpty()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.IsGrenadeEmpty");

	ASTExtraPlayerCharacter_IsGrenadeEmpty_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.HideNightVisionFrame
// (Native, Public, BlueprintCallable)

void ASTExtraPlayerCharacter::HideNightVisionFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.HideNightVisionFrame");

	ASTExtraPlayerCharacter_HideNightVisionFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleParachuteStateChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<EParachuteState>   NewState                       (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::HandleParachuteStateChanged(TEnumAsByte<EParachuteState> NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleParachuteStateChanged");

	ASTExtraPlayerCharacter_HandleParachuteStateChanged_Params params;
	params.NewState = NewState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleBulletOverlap
// (Final, Native, Public, HasOutParms)
// Parameters:
// class AActor*                  BulletActor                    (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitResult                      (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// TArray<struct FHitResult>      HitResults                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerCharacter::HandleBulletOverlap(class AActor* BulletActor, const struct FHitResult& HitResult, TArray<struct FHitResult> HitResults)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleBulletOverlap");

	ASTExtraPlayerCharacter_HandleBulletOverlap_Params params;
	params.BulletActor = BulletActor;
	params.HitResult = HitResult;
	params.HitResults = HitResults;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleAIInstigateBulletOverlap
// (Final, Native, Public, HasOutParms)
// Parameters:
// class ASTExtraBaseCharacter*   InstigatorCharacter            (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              HitResult                      (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// TArray<struct FHitResult>      HitResults                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ASTExtraPlayerCharacter::HandleAIInstigateBulletOverlap(class ASTExtraBaseCharacter* InstigatorCharacter, const struct FHitResult& HitResult, TArray<struct FHitResult> HitResults)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.HandleAIInstigateBulletOverlap");

	ASTExtraPlayerCharacter_HandleAIInstigateBulletOverlap_Params params;
	params.InstigatorCharacter = InstigatorCharacter;
	params.HitResult = HitResult;
	params.HitResults = HitResults;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetThirdPersonSpringArm
// (Event, Public, BlueprintEvent)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraPlayerCharacter::GetThirdPersonSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetThirdPersonSpringArm");

	ASTExtraPlayerCharacter_GetThirdPersonSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetThirdPersonCamera
// (Event, Public, BlueprintEvent)
// Parameters:
// class UCameraComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCameraComponent* ASTExtraPlayerCharacter::GetThirdPersonCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetThirdPersonCamera");

	ASTExtraPlayerCharacter_GetThirdPersonCamera_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetSwimRotateX_Ex
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraPlayerCharacter::GetSwimRotateX_Ex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetSwimRotateX_Ex");

	ASTExtraPlayerCharacter_GetSwimRotateX_Ex_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetScopeSpringArm
// (Event, Public, BlueprintEvent)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraPlayerCharacter::GetScopeSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetScopeSpringArm");

	ASTExtraPlayerCharacter_GetScopeSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetScopeCamera
// (Event, Public, BlueprintEvent)
// Parameters:
// class UCameraComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCameraComponent* ASTExtraPlayerCharacter::GetScopeCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetScopeCamera");

	ASTExtraPlayerCharacter_GetScopeCamera_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetPlayerControllerSafety
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* ASTExtraPlayerCharacter::GetPlayerControllerSafety()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetPlayerControllerSafety");

	ASTExtraPlayerCharacter_GetPlayerControllerSafety_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFPPSpringArm
// (Event, Public, BlueprintEvent)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraPlayerCharacter::GetFPPSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFPPSpringArm");

	ASTExtraPlayerCharacter_GetFPPSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFPPCamera
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UCameraComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCameraComponent* ASTExtraPlayerCharacter::GetFPPCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFPPCamera");

	ASTExtraPlayerCharacter_GetFPPCamera_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFirstPersonSpringArm
// (Event, Public, BlueprintEvent)
// Parameters:
// class USpringArmComponent*     ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class USpringArmComponent* ASTExtraPlayerCharacter::GetFirstPersonSpringArm()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFirstPersonSpringArm");

	ASTExtraPlayerCharacter_GetFirstPersonSpringArm_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFirstPersonCamera
// (Event, Public, BlueprintEvent)
// Parameters:
// class UCameraComponent*        ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UCameraComponent* ASTExtraPlayerCharacter::GetFirstPersonCamera()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetFirstPersonCamera");

	ASTExtraPlayerCharacter_GetFirstPersonCamera_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.GetBonePos
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FName                   BoneName                       (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraPlayerCharacter::GetBonePos(const struct FName& BoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.GetBonePos");

	ASTExtraPlayerCharacter_GetBonePos_Params params;
	params.BoneName = BoneName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.FreeFallShakeCam
// (Final, Native, Public)

void ASTExtraPlayerCharacter::FreeFallShakeCam()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.FreeFallShakeCam");

	ASTExtraPlayerCharacter_FreeFallShakeCam_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.FinishUpdatingParachuteFallingCameraDistance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            nearPlaneDistance              (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraPlayerCharacter::FinishUpdatingParachuteFallingCameraDistance(int nearPlaneDistance)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.FinishUpdatingParachuteFallingCameraDistance");

	ASTExtraPlayerCharacter_FinishUpdatingParachuteFallingCameraDistance_Params params;
	params.nearPlaneDistance = nearPlaneDistance;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ClientPlayEarSound
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient, NetValidate)
// Parameters:
// class ASTExtraShootWeapon*     InstigateWeapon                (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 FlySoundPos                    (Parm, IsPlainOldData)

void ASTExtraPlayerCharacter::ClientPlayEarSound(class ASTExtraShootWeapon* InstigateWeapon, const struct FVector& FlySoundPos)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ClientPlayEarSound");

	ASTExtraPlayerCharacter_ClientPlayEarSound_Params params;
	params.InstigateWeapon = InstigateWeapon;
	params.FlySoundPos = FlySoundPos;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraPlayerCharacter.ClearHPUI
// (Native, Public)

void ASTExtraPlayerCharacter::ClearHPUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraPlayerCharacter.ClearHPUI");

	ASTExtraPlayerCharacter_ClearHPUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.ResetBulletDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeaponBulletBase::ResetBulletDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.ResetBulletDelegate__DelegateSignature");

	ASTExtraShootWeaponBulletBase_ResetBulletDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.OnImpactDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)
// Parameters:
// struct FHitResult              HitInfo                        (Parm, IsPlainOldData)

void ASTExtraShootWeaponBulletBase::OnImpactDelegate__DelegateSignature(const struct FHitResult& HitInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.OnImpactDelegate__DelegateSignature");

	ASTExtraShootWeaponBulletBase_OnImpactDelegate__DelegateSignature_Params params;
	params.HitInfo = HitInfo;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraShootWeaponBulletBase.OnImpact
// (Native, Protected, HasOutParms)
// Parameters:
// struct FHitResult              _ImpactResult                  (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void ASTExtraShootWeaponBulletBase::OnImpact(const struct FHitResult& _ImpactResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraShootWeaponBulletBase.OnImpact");

	ASTExtraShootWeaponBulletBase_OnImpact_Params params;
	params._ImpactResult = _ImpactResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.LaunchBulletDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void ASTExtraShootWeaponBulletBase::LaunchBulletDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.STExtraShootWeaponBulletBase.LaunchBulletDelegate__DelegateSignature");

	ASTExtraShootWeaponBulletBase_LaunchBulletDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.OnRep_SimpleDamageData
// (Final, Native, Public)

void ASTExtraSimpleCharacter::OnRep_SimpleDamageData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.OnRep_SimpleDamageData");

	ASTExtraSimpleCharacter_OnRep_SimpleDamageData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.GetAnimParam
// (Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FSimpleCharAnimParamList ReturnValue                    (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm)

struct FSimpleCharAnimParamList ASTExtraSimpleCharacter::GetAnimParam(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.GetAnimParam");

	ASTExtraSimpleCharacter_GetAnimParam_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.DisappearOnDeath
// (Final, Native, Protected)

void ASTExtraSimpleCharacter::DisappearOnDeath()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.DisappearOnDeath");

	ASTExtraSimpleCharacter_DisappearOnDeath_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.ClearOnDeath
// (Final, Native, Protected)
// Parameters:
// class AController*             EventInstigater                (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::ClearOnDeath(class AController* EventInstigater)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.ClearOnDeath");

	ASTExtraSimpleCharacter_ClearOnDeath_Params params;
	params.EventInstigater = EventInstigater;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateVehicleDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVehicleDamageEvent     VehicleDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateVehicleDamage(float BaseDamage, const struct FVehicleDamageEvent& VehicleDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateVehicleDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateVehicleDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.VehicleDamageEvent = VehicleDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateRadialDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FRadialDamageEvent      PointDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHeath                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateRadialDamage(float BaseDamage, const struct FRadialDamageEvent& PointDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHeath, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateRadialDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateRadialDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PointDamageEvent = PointDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHeath = ServerCurHeath;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulatePoisonDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FPoisonDamageEvent      PoisonDamageEvent              (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulatePoisonDamage(float BaseDamage, const struct FPoisonDamageEvent& PoisonDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulatePoisonDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulatePoisonDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PoisonDamageEvent = PoisonDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulatePointDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTPointDamageEvent     PointDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHeath                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulatePointDamage(float BaseDamage, const struct FSTPointDamageEvent& PointDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHeath, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulatePointDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulatePointDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.PointDamageEvent = PointDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHeath = ServerCurHeath;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateMeleeDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FMeleeDamageEvent       MeleeDamageEvent               (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateMeleeDamage(float BaseDamage, const struct FMeleeDamageEvent& MeleeDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateMeleeDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateMeleeDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.MeleeDamageEvent = MeleeDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateFallingDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FFallingDamageEvent     FallingDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateFallingDamage(float BaseDamage, const struct FFallingDamageEvent& FallingDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateFallingDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateFallingDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.FallingDamageEvent = FallingDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateDrowningDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FDrowningDamageEvent    DrowningDamageEvent            (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateDrowningDamage(float BaseDamage, const struct FDrowningDamageEvent& DrowningDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateDrowningDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateDrowningDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.DrowningDamageEvent = DrowningDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateBurningDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTBurningDamageEvent   BurningDamageEvent             (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateBurningDamage(float BaseDamage, const struct FSTBurningDamageEvent& BurningDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateBurningDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateBurningDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.BurningDamageEvent = BurningDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateAirAttackDamage
// (Net, Native, Event, NetMulticast, Protected, NetValidate)
// Parameters:
// float                          BaseDamage                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FSTAirAttackRadialDamageEvent AirAttackDamageEvent           (ConstParm, Parm, ReferenceParm)
// class APawn*                   DamageInstigatorPawn           (Parm, ZeroConstructor, IsPlainOldData)
// float                          ServerCurHealth                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           _isFatalHealthCost             (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsHeadShotDamage               (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BroadcastClientsSimulateAirAttackDamage(float BaseDamage, const struct FSTAirAttackRadialDamageEvent& AirAttackDamageEvent, class APawn* DamageInstigatorPawn, float ServerCurHealth, bool _isFatalHealthCost, bool IsHeadShotDamage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BroadcastClientsSimulateAirAttackDamage");

	ASTExtraSimpleCharacter_BroadcastClientsSimulateAirAttackDamage_Params params;
	params.BaseDamage = BaseDamage;
	params.AirAttackDamageEvent = AirAttackDamageEvent;
	params.DamageInstigatorPawn = DamageInstigatorPawn;
	params.ServerCurHealth = ServerCurHealth;
	params._isFatalHealthCost = _isFatalHealthCost;
	params.IsHeadShotDamage = IsHeadShotDamage;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BPNotifyStartDying
// (Event, Protected, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  KillingHitDamageType           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BPNotifyStartDying(class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* KillingHitDamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BPNotifyStartDying");

	ASTExtraSimpleCharacter_BPNotifyStartDying_Params params;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.KillingHitDamageType = KillingHitDamageType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BPNotifyDeathEnd
// (Event, Protected, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// class AController*             Killer                         (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              KillingHitInfo                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 KillingHitImpulseDir           (Parm, IsPlainOldData)
// class UClass*                  KillingHitDamageType           (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraSimpleCharacter::BPNotifyDeathEnd(class AController* Killer, class AActor* DamageCauser, const struct FHitResult& KillingHitInfo, const struct FVector& KillingHitImpulseDir, class UClass* KillingHitDamageType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BPNotifyDeathEnd");

	ASTExtraSimpleCharacter_BPNotifyDeathEnd_Params params;
	params.Killer = Killer;
	params.DamageCauser = DamageCauser;
	params.KillingHitInfo = KillingHitInfo;
	params.KillingHitImpulseDir = KillingHitImpulseDir;
	params.KillingHitDamageType = KillingHitDamageType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.BPDie
// (Native, Event, Protected, HasOutParms, BlueprintEvent)
// Parameters:
// float                          KillingDamage                  (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             EventInstigator                (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  DamageCauser                   (Parm, ZeroConstructor, IsPlainOldData)
// struct FDamageEvent            DamageEvent                    (ConstParm, Parm, OutParm, ReferenceParm)

void ASTExtraSimpleCharacter::BPDie(float KillingDamage, class AController* EventInstigator, class AActor* DamageCauser, const struct FDamageEvent& DamageEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.BPDie");

	ASTExtraSimpleCharacter_BPDie_Params params;
	params.KillingDamage = KillingDamage;
	params.EventInstigator = EventInstigator;
	params.DamageCauser = DamageCauser;
	params.DamageEvent = DamageEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraSimpleCharacter.AddHealthSafety
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          AddVal                         (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             DamageInstigator               (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IsDamageFromVehicleExplode     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ASTExtraSimpleCharacter::AddHealthSafety(float AddVal, class AController* DamageInstigator, bool IsDamageFromVehicleExplode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraSimpleCharacter.AddHealthSafety");

	ASTExtraSimpleCharacter_AddHealthSafety_Params params;
	params.AddVal = AddVal;
	params.DamageInstigator = DamageInstigator;
	params.IsDamageFromVehicleExplode = IsDamageFromVehicleExplode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.PrintGameLog
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FString                 LogContent                     (Parm, ZeroConstructor)

void USTExtraUIUtils::PrintGameLog(const struct FString& LogContent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.PrintGameLog");

	USTExtraUIUtils_PrintGameLog_Params params;
	params.LogContent = LogContent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerRoleID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraUIUtils::GetOwningPlayerRoleID(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerRoleID");

	USTExtraUIUtils_GetOwningPlayerRoleID_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerPawnOrVehicleDriver
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraPlayerCharacter* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerCharacter* USTExtraUIUtils::GetOwningPlayerPawnOrVehicleDriver(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerPawnOrVehicleDriver");

	USTExtraUIUtils_GetOwningPlayerPawnOrVehicleDriver_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerOpenID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraUIUtils::GetOwningPlayerOpenID(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerOpenID");

	USTExtraUIUtils_GetOwningPlayerOpenID_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerNoDefault
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* USTExtraUIUtils::GetOwningPlayerNoDefault(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayerNoDefault");

	USTExtraUIUtils_GetOwningPlayerNoDefault_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* USTExtraUIUtils::GetOwningPlayer(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetOwningPlayer");

	USTExtraUIUtils_GetOwningPlayer_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetFloatAsStringWithPrecision
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// float                          TheFloat                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            Precision                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IncludeLeadingZero             (Parm, ZeroConstructor, IsPlainOldData)
// struct FText                   ReturnValue                    (Parm, OutParm, ReturnParm)

struct FText USTExtraUIUtils::GetFloatAsStringWithPrecision(float TheFloat, int Precision, bool IncludeLeadingZero)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetFloatAsStringWithPrecision");

	USTExtraUIUtils_GetFloatAsStringWithPrecision_Params params;
	params.TheFloat = TheFloat;
	params.Precision = Precision;
	params.IncludeLeadingZero = IncludeLeadingZero;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetCurPlayerState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class ASTExtraPlayerState*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerState* USTExtraUIUtils::GetCurPlayerState(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetCurPlayerState");

	USTExtraUIUtils_GetCurPlayerState_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.GetBattleID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraUIUtils::GetBattleID(class UUAEUserWidget* UAEUserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.GetBattleID");

	USTExtraUIUtils_GetBattleID_Params params;
	params.UAEUserWidget = UAEUserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraUIUtils.CreateModeUAEUserWidget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UAEUserWidget                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FString                 Path                           (Parm, ZeroConstructor)
// class UUAEUserWidget*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UUAEUserWidget* USTExtraUIUtils::CreateModeUAEUserWidget(class UUAEUserWidget* UAEUserWidget, const struct FString& Path)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraUIUtils.CreateModeUAEUserWidget");

	USTExtraUIUtils_CreateModeUAEUserWidget_Params params;
	params.UAEUserWidget = UAEUserWidget;
	params.Path = Path;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.OnExpoldeStopWheel
// (Final, Native, Public)

void USTExtraVehicleMovementComponent4W::OnExpoldeStopWheel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.OnExpoldeStopWheel");

	USTExtraVehicleMovementComponent4W_OnExpoldeStopWheel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatDetached
// (Final, Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraVehicleMovementComponent4W::HandleOnSeatDetached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatDetached");

	USTExtraVehicleMovementComponent4W_HandleOnSeatDetached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatChanged
// (Final, Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        LastSeatType                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            LastSeatIdx                    (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        NewSeatType                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewSeatIdx                     (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraVehicleMovementComponent4W::HandleOnSeatChanged(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType LastSeatType, int LastSeatIdx, ESTExtraVehicleSeatType NewSeatType, int NewSeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatChanged");

	USTExtraVehicleMovementComponent4W_HandleOnSeatChanged_Params params;
	params.Character = Character;
	params.LastSeatType = LastSeatType;
	params.LastSeatIdx = LastSeatIdx;
	params.NewSeatType = NewSeatType;
	params.NewSeatIdx = NewSeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatAttached
// (Final, Native, Protected)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraVehicleMovementComponent4W::HandleOnSeatAttached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.HandleOnSeatAttached");

	USTExtraVehicleMovementComponent4W_HandleOnSeatAttached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.ForceWheelsRotate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DriveTorque                    (Parm, ZeroConstructor, IsPlainOldData)

void USTExtraVehicleMovementComponent4W::ForceWheelsRotate(float DriveTorque)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.ForceWheelsRotate");

	USTExtraVehicleMovementComponent4W_ForceWheelsRotate_Params params;
	params.DriveTorque = DriveTorque;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.ClearDestroyedWheel
// (Final, Native, Public, BlueprintCallable)

void USTExtraVehicleMovementComponent4W::ClearDestroyedWheel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleMovementComponent4W.ClearDestroyedWheel");

	USTExtraVehicleMovementComponent4W_ClearDestroyedWheel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.IsPassenger
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraVehicleUtils::IsPassenger(class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.IsPassenger");

	USTExtraVehicleUtils_IsPassenger_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.IsDriver
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTExtraVehicleUtils::IsDriver(class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.IsDriver");

	USTExtraVehicleUtils_IsDriver_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetWorldFromActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                  Actor                          (Parm, ZeroConstructor, IsPlainOldData)
// class UWorld*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UWorld* USTExtraVehicleUtils::GetWorldFromActor(class AActor* Actor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetWorldFromActor");

	USTExtraVehicleUtils_GetWorldFromActor_Params params;
	params.Actor = Actor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehicleUserComp
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)
// class UVehicleUserComponent*   ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UVehicleUserComponent* USTExtraVehicleUtils::GetVehicleUserComp(class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehicleUserComp");

	USTExtraVehicleUtils_GetVehicleUserComp_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehiclePartByBoneName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraVehicleBase*     Vehicle                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   BoneName                       (Parm, ZeroConstructor, IsPlainOldData)
// EAvatarDamagePosition          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

EAvatarDamagePosition USTExtraVehicleUtils::GetVehiclePartByBoneName(class ASTExtraVehicleBase* Vehicle, const struct FName& BoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehiclePartByBoneName");

	USTExtraVehicleUtils_GetVehiclePartByBoneName_Params params;
	params.Vehicle = Vehicle;
	params.BoneName = BoneName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehicleInfo
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraVehicleBase*     VH                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraVehicleUtils::GetVehicleInfo(class ASTExtraVehicleBase* VH)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetVehicleInfo");

	USTExtraVehicleUtils_GetVehicleInfo_Params params;
	params.VH = VH;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetFirstVehicleUserComp
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UWorld*                  World                          (Parm, ZeroConstructor, IsPlainOldData)
// class UVehicleUserComponent*   ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UVehicleUserComponent* USTExtraVehicleUtils::GetFirstVehicleUserComp(class UWorld* World)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetFirstVehicleUserComp");

	USTExtraVehicleUtils_GetFirstVehicleUserComp_Params params;
	params.World = World;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetController
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* USTExtraVehicleUtils::GetController(class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetController");

	USTExtraVehicleUtils_GetController_Params params;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetCharacterInfo
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   CH                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString USTExtraVehicleUtils::GetCharacterInfo(class ASTExtraBaseCharacter* CH)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetCharacterInfo");

	USTExtraVehicleUtils_GetCharacterInfo_Params params;
	params.CH = CH;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.GetCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* USTExtraVehicleUtils::GetCharacter(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.GetCharacter");

	USTExtraVehicleUtils_GetCharacter_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraVehicleUtils.AirDropVehicle
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UWorld*                  World                          (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 SpawnLoc                       (Parm, IsPlainOldData)
// struct FVehicleGenerateRandomInfo generateInfo                   (Parm)
// class ASTExtraVehicleBase*     ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraVehicleBase* USTExtraVehicleUtils::AirDropVehicle(class UWorld* World, const struct FVector& SpawnLoc, const struct FVehicleGenerateRandomInfo& generateInfo)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraVehicleUtils.AirDropVehicle");

	USTExtraVehicleUtils_AirDropVehicle_Params params;
	params.World = World;
	params.SpawnLoc = SpawnLoc;
	params.generateInfo = generateInfo;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.STServerUpdateState
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int8_t                         InSteeringInput                (Parm, ZeroConstructor, IsPlainOldData)
// int8_t                         InThrottleInput                (Parm, ZeroConstructor, IsPlainOldData)
// int8_t                         InBrakeInput                   (Parm, ZeroConstructor, IsPlainOldData)
// int8_t                         InHandbrakeInput               (Parm, ZeroConstructor, IsPlainOldData)
// int8_t                         CurrentGear                    (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWheeledVehicle::STServerUpdateState(int8_t InSteeringInput, int8_t InThrottleInput, int8_t InBrakeInput, int8_t InHandbrakeInput, int8_t CurrentGear)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.STServerUpdateState");

	ASTExtraWheeledVehicle_STServerUpdateState_Params params;
	params.InSteeringInput = InSteeringInput;
	params.InThrottleInput = InThrottleInput;
	params.InBrakeInput = InBrakeInput;
	params.InHandbrakeInput = InHandbrakeInput;
	params.CurrentGear = CurrentGear;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.PostLoadFPPMesh
// (Native, Public, BlueprintCallable)

void ASTExtraWheeledVehicle::PostLoadFPPMesh()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.PostLoadFPPMesh");

	ASTExtraWheeledVehicle_PostLoadFPPMesh_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.OnWheelsLanded
// (Final, Native, Protected)

void ASTExtraWheeledVehicle::OnWheelsLanded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.OnWheelsLanded");

	ASTExtraWheeledVehicle_OnWheelsLanded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.OnRep_ReplicatedState
// (Final, Native, Public)

void ASTExtraWheeledVehicle::OnRep_ReplicatedState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.OnRep_ReplicatedState");

	ASTExtraWheeledVehicle_OnRep_ReplicatedState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.OnGearChanged
// (Final, Native, Protected)
// Parameters:
// bool                           bIsUp                          (Parm, ZeroConstructor, IsPlainOldData)

void ASTExtraWheeledVehicle::OnGearChanged(bool bIsUp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.OnGearChanged");

	ASTExtraWheeledVehicle_OnGearChanged_Params params;
	params.bIsUp = bIsUp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.GetVehicleSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float ASTExtraWheeledVehicle::GetVehicleSpeed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.GetVehicleSpeed");

	ASTExtraWheeledVehicle_GetVehicleSpeed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.GetRotationInputDir
// (Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector ASTExtraWheeledVehicle::GetRotationInputDir()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.GetRotationInputDir");

	ASTExtraWheeledVehicle_GetRotationInputDir_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STExtraWheeledVehicle.BroadcastClientVehicleWheelDestroyEffect
// (Net, Native, Event, NetMulticast, Public)

void ASTExtraWheeledVehicle::BroadcastClientVehicleWheelDestroyEffect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STExtraWheeledVehicle.BroadcastClientVehicleWheelDestroyEffect");

	ASTExtraWheeledVehicle_BroadcastClientVehicleWheelDestroyEffect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STPlayerCameraManager.SetClientSimulatingViewTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bNewValue                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTPlayerCameraManager::SetClientSimulatingViewTarget(bool bNewValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STPlayerCameraManager.SetClientSimulatingViewTarget");

	ASTPlayerCameraManager_SetClientSimulatingViewTarget_Params params;
	params.bNewValue = bNewValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.StopScreenParticleEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)

void USTScreenAppearanceComponent::StopScreenParticleEffect(TEnumAsByte<EScreenParticleEffectType> EffectType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.StopScreenParticleEffect");

	USTScreenAppearanceComponent_StopScreenParticleEffect_Params params;
	params.EffectType = EffectType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.StopScreenAppearance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)

void USTScreenAppearanceComponent::StopScreenAppearance(const struct FString& AppearanceName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.StopScreenAppearance");

	USTScreenAppearanceComponent_StopScreenAppearance_Params params;
	params.AppearanceName = AppearanceName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.SetScreenParticleParam
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          InEffectValue                  (Parm, ZeroConstructor, IsPlainOldData)

void USTScreenAppearanceComponent::SetScreenParticleParam(TEnumAsByte<EScreenParticleEffectType> EffectType, float InEffectValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.SetScreenParticleParam");

	USTScreenAppearanceComponent_SetScreenParticleParam_Params params;
	params.EffectType = EffectType;
	params.InEffectValue = InEffectValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayScreenParticleEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)
// float                          InEffectValue                  (Parm, ZeroConstructor, IsPlainOldData)

void USTScreenAppearanceComponent::PlayScreenParticleEffect(TEnumAsByte<EScreenParticleEffectType> EffectType, float InEffectValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayScreenParticleEffect");

	USTScreenAppearanceComponent_PlayScreenParticleEffect_Params params;
	params.EffectType = EffectType;
	params.InEffectValue = InEffectValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayPresentScreenAppearance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)
// class UMaterialInstanceDynamic* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInstanceDynamic* USTScreenAppearanceComponent::PlayPresentScreenAppearance(const struct FString& AppearanceName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayPresentScreenAppearance");

	USTScreenAppearanceComponent_PlayPresentScreenAppearance_Params params;
	params.AppearanceName = AppearanceName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayCustomScreenAppearance
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)
// class UMaterialInterface*      MatToPlay                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          LifeSpan                       (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstanceDynamic* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInstanceDynamic* USTScreenAppearanceComponent::PlayCustomScreenAppearance(const struct FString& AppearanceName, class UMaterialInterface* MatToPlay, float LifeSpan)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.PlayCustomScreenAppearance");

	USTScreenAppearanceComponent_PlayCustomScreenAppearance_Params params;
	params.AppearanceName = AppearanceName;
	params.MatToPlay = MatToPlay;
	params.LifeSpan = LifeSpan;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.IsScreenAppearancePlaying
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool USTScreenAppearanceComponent::IsScreenAppearancePlaying(const struct FString& AppearanceName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.IsScreenAppearancePlaying");

	USTScreenAppearanceComponent_IsScreenAppearancePlaying_Params params;
	params.AppearanceName = AppearanceName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponent.HandleEffectLoadFinish
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EScreenParticleEffectType> EffectType                     (Parm, ZeroConstructor, IsPlainOldData)

void USTScreenAppearanceComponent::HandleEffectLoadFinish(TEnumAsByte<EScreenParticleEffectType> EffectType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponent.HandleEffectLoadFinish");

	USTScreenAppearanceComponent_HandleEffectLoadFinish_Params params;
	params.EffectType = EffectType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponentAdditional.StopScreenAppearanceWithTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)
// struct FString                 TagString                      (Parm, ZeroConstructor)

void USTScreenAppearanceComponentAdditional::StopScreenAppearanceWithTag(const struct FString& AppearanceName, const struct FString& TagString)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponentAdditional.StopScreenAppearanceWithTag");

	USTScreenAppearanceComponentAdditional_StopScreenAppearanceWithTag_Params params;
	params.AppearanceName = AppearanceName;
	params.TagString = TagString;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STScreenAppearanceComponentAdditional.PlayCustomScreenAppearanceWithTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 AppearanceName                 (Parm, ZeroConstructor)
// struct FString                 TagString                      (Parm, ZeroConstructor)
// struct FName                   paramShaderUniformName         (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInterface*      MatToPlay                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          LifeSpan                       (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstanceDynamic* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInstanceDynamic* USTScreenAppearanceComponentAdditional::PlayCustomScreenAppearanceWithTag(const struct FString& AppearanceName, const struct FString& TagString, const struct FName& paramShaderUniformName, class UMaterialInterface* MatToPlay, float LifeSpan)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STScreenAppearanceComponentAdditional.PlayCustomScreenAppearanceWithTag");

	USTScreenAppearanceComponentAdditional_PlayCustomScreenAppearanceWithTag_Params params;
	params.AppearanceName = AppearanceName;
	params.TagString = TagString;
	params.paramShaderUniformName = paramShaderUniformName;
	params.MatToPlay = MatToPlay;
	params.LifeSpan = LifeSpan;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.STSpectatorPawn.OnStopWalking
// (Final, Native, Protected)

void ASTSpectatorPawn::OnStopWalking()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STSpectatorPawn.OnStopWalking");

	ASTSpectatorPawn_OnStopWalking_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STSpectatorPawn.OnStopRunning
// (Final, Native, Protected)

void ASTSpectatorPawn::OnStopRunning()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STSpectatorPawn.OnStopRunning");

	ASTSpectatorPawn_OnStopRunning_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STSpectatorPawn.OnStartWalking
// (Final, Native, Protected)

void ASTSpectatorPawn::OnStartWalking()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STSpectatorPawn.OnStartWalking");

	ASTSpectatorPawn_OnStartWalking_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STSpectatorPawn.OnStartRunning
// (Final, Native, Protected)

void ASTSpectatorPawn::OnStartRunning()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STSpectatorPawn.OnStartRunning");

	ASTSpectatorPawn_OnStartRunning_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.STSpectatorPawn.MoveUp
// (Final, Native, Protected)
// Parameters:
// float                          AxisValue                      (Parm, ZeroConstructor, IsPlainOldData)

void ASTSpectatorPawn::MoveUp(float AxisValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.STSpectatorPawn.MoveUp");

	ASTSpectatorPawn_MoveUp_Params params;
	params.AxisValue = AxisValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SurviveHUD.OnAsyncLoadingFinished
// (Final, Native, Public)

void ASurviveHUD::OnAsyncLoadingFinished()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SurviveHUD.OnAsyncLoadingFinished");

	ASurviveHUD_OnAsyncLoadingFinished_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.SurviveHUD.EnableCrosshair
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnable                        (Parm, ZeroConstructor, IsPlainOldData)

void ASurviveHUD::EnableCrosshair(bool bEnable)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.SurviveHUD.EnableCrosshair");

	ASurviveHUD_EnableCrosshair_Params params;
	params.bEnable = bEnable;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetKeyOperation.Update
// (Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetKeyOperation::Update(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.Update");

	UTargetKeyOperation_Update_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.ToString
// (Final, Native, Public, Const)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UTargetKeyOperation::ToString()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.ToString");

	UTargetKeyOperation_ToString_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.TaskRemoved
// (Native, Public)

void UTargetKeyOperation::TaskRemoved()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.TaskRemoved");

	UTargetKeyOperation_TaskRemoved_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetKeyOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetKeyOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.Start");

	UTargetKeyOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetKeyOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.IsValidate");

	UTargetKeyOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.IsReachable
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetKeyOperation::IsReachable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.IsReachable");

	UTargetKeyOperation_IsReachable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.Finish
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetKeyOperation::Finish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.Finish");

	UTargetKeyOperation_Finish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetKeyOperation.DebugDraw
// (Native, Public, HasDefaults)
// Parameters:
// struct FColor                  debugColor                     (Parm, IsPlainOldData)
// bool                           isPersist                      (Parm, ZeroConstructor, IsPlainOldData)

void UTargetKeyOperation::DebugDraw(const struct FColor& debugColor, bool isPersist)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.DebugDraw");

	UTargetKeyOperation_DebugDraw_Params params;
	params.debugColor = debugColor;
	params.isPersist = isPersist;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetKeyOperation.Awake
// (Native, Public)

void UTargetKeyOperation::Awake()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetKeyOperation.Awake");

	UTargetKeyOperation_Awake_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetMoveOperation.Update
// (Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetMoveOperation::Update(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.Update");

	UTargetMoveOperation_Update_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetMoveOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.Start");

	UTargetMoveOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.MoveCloseToTargetWithSprint
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetMoveOperation::MoveCloseToTargetWithSprint(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.MoveCloseToTargetWithSprint");

	UTargetMoveOperation_MoveCloseToTargetWithSprint_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.MoveCloseToTarget
// (Final, Native, Public)
// Parameters:
// float                          DletaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetMoveOperation::MoveCloseToTarget(float DletaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.MoveCloseToTarget");

	UTargetMoveOperation_MoveCloseToTarget_Params params;
	params.DletaTime = DletaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetMoveOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.IsValidate");

	UTargetMoveOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.IsReachable
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetMoveOperation::IsReachable()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.IsReachable");

	UTargetMoveOperation_IsReachable_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetMoveOperation.Finish
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetMoveOperation::Finish()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetMoveOperation.Finish");

	UTargetMoveOperation_Finish_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetSprintOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetSprintOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetSprintOperation.Start");

	UTargetSprintOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetSprintOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetSprintOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetSprintOperation.IsValidate");

	UTargetSprintOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetJumpOperation.TaskRemoved
// (Native, Public)

void UTargetJumpOperation::TaskRemoved()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetJumpOperation.TaskRemoved");

	UTargetJumpOperation_TaskRemoved_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetJumpOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetJumpOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetJumpOperation.Start");

	UTargetJumpOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetJumpOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetJumpOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetJumpOperation.IsValidate");

	UTargetJumpOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetJumpOperation.DebugDraw
// (Native, Public, HasDefaults)
// Parameters:
// struct FColor                  debugColor                     (Parm, IsPlainOldData)
// bool                           isPersist                      (Parm, ZeroConstructor, IsPlainOldData)

void UTargetJumpOperation::DebugDraw(const struct FColor& debugColor, bool isPersist)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetJumpOperation.DebugDraw");

	UTargetJumpOperation_DebugDraw_Params params;
	params.debugColor = debugColor;
	params.isPersist = isPersist;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetJumpOperation.Awake
// (Native, Public)

void UTargetJumpOperation::Awake()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetJumpOperation.Awake");

	UTargetJumpOperation_Awake_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TargetCrouchOperation.Update
// (Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetCrouchOperation::Update(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetCrouchOperation.Update");

	UTargetCrouchOperation_Update_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetCrouchOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetCrouchOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetCrouchOperation.Start");

	UTargetCrouchOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetCrouchOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetCrouchOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetCrouchOperation.IsValidate");

	UTargetCrouchOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetVehicleOperation.Update
// (Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetVehicleOperation::Update(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetVehicleOperation.Update");

	UTargetVehicleOperation_Update_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetVehicleOperation.Start
// (Native, Public)
// Parameters:
// TEnumAsByte<EOperationRunResult> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EOperationRunResult> UTargetVehicleOperation::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetVehicleOperation.Start");

	UTargetVehicleOperation_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TargetVehicleOperation.IsValidate
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTargetVehicleOperation::IsValidate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TargetVehicleOperation.IsValidate");

	UTargetVehicleOperation_IsValidate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TeammatePositionWidget.SetSavedPlayerState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerState*     SPS                            (Parm, ZeroConstructor, IsPlainOldData)

void UTeammatePositionWidget::SetSavedPlayerState(class ASTExtraPlayerState* SPS)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TeammatePositionWidget.SetSavedPlayerState");

	UTeammatePositionWidget_SetSavedPlayerState_Params params;
	params.SPS = SPS;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TeammatePositionWidget.SetCurrentWidgetVisible
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                           Visible                        (Parm, ZeroConstructor, IsPlainOldData)

void UTeammatePositionWidget::SetCurrentWidgetVisible(bool Visible)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TeammatePositionWidget.SetCurrentWidgetVisible");

	UTeammatePositionWidget_SetCurrentWidgetVisible_Params params;
	params.Visible = Visible;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TerminatorWidget.SetBaseCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   BC                             (Parm, ZeroConstructor, IsPlainOldData)

void UTerminatorWidget::SetBaseCharacter(class ASTExtraBaseCharacter* BC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TerminatorWidget.SetBaseCharacter");

	UTerminatorWidget_SetBaseCharacter_Params params;
	params.BC = BC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TirggerItem_TriggerBox.OnTriggerExit
// (Final, Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATirggerItem_TriggerBox::OnTriggerExit(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TirggerItem_TriggerBox.OnTriggerExit");

	ATirggerItem_TriggerBox_OnTriggerExit_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TirggerItem_TriggerBox.OnTriggerEnter
// (Final, Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATirggerItem_TriggerBox::OnTriggerEnter(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TirggerItem_TriggerBox.OnTriggerEnter");

	ATirggerItem_TriggerBox_OnTriggerEnter_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TrailMarkActor.UpdateInput
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FTrailMarkInputData> NewInput                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void ATrailMarkActor::UpdateInput(TArray<struct FTrailMarkInputData> NewInput)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TrailMarkActor.UpdateInput");

	ATrailMarkActor_UpdateInput_Params params;
	params.NewInput = NewInput;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TrailMarkActor.StopUpdate
// (Final, Native, Public, BlueprintCallable)

void ATrailMarkActor::StopUpdate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TrailMarkActor.StopUpdate");

	ATrailMarkActor_StopUpdate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TrailMarkActor.IsUpdating
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ATrailMarkActor::IsUpdating()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TrailMarkActor.IsUpdating");

	ATrailMarkActor_IsUpdating_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TreasureBox.OnPickUpDataEmptyOnServer
// (Event, Public, BlueprintEvent)

void ATreasureBox::OnPickUpDataEmptyOnServer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TreasureBox.OnPickUpDataEmptyOnServer");

	ATreasureBox_OnPickUpDataEmptyOnServer_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TreasureBox.GenerateWrappersBox
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// TArray<struct FAirDropBoxGenerateWrapperItemData> DataList                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 BoxLoc                         (Parm, IsPlainOldData)

void ATreasureBox::GenerateWrappersBox(TArray<struct FAirDropBoxGenerateWrapperItemData> DataList, const struct FVector& BoxLoc)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TreasureBox.GenerateWrappersBox");

	ATreasureBox_GenerateWrappersBox_Params params;
	params.DataList = DataList;
	params.BoxLoc = BoxLoc;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.SetTargetParam
// (Native, Public)
// Parameters:
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_Task::SetTargetParam(int Value)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.SetTargetParam");

	UTriggerCondition_Task_SetTargetParam_Params params;
	params.Value = Value;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.SetConditionParam
// (Native, Public)
// Parameters:
// int                            Value                          (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_Task::SetConditionParam(int Value)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.SetConditionParam");

	UTriggerCondition_Task_SetConditionParam_Params params;
	params.Value = Value;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.IsSatisfy
// (Native, Public)
// Parameters:
// class UTriggerEvent*           Event                          (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::IsSatisfy(class UTriggerEvent* Event)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.IsSatisfy");

	UTriggerCondition_Task_IsSatisfy_Params params;
	params.Event = Event;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.IsSameCondition
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> InTaskConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::IsSameCondition(TEnumAsByte<ETaskConditionType> InTaskConditionType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.IsSameCondition");

	UTriggerCondition_Task_IsSameCondition_Params params;
	params.InTaskConditionType = InTaskConditionType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.FillDataSource
// (Native, Public)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::FillDataSource(class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.FillDataSource");

	UTriggerCondition_Task_FillDataSource_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.DeactiveCondition
// (Native, Public)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::DeactiveCondition(class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.DeactiveCondition");

	UTriggerCondition_Task_DeactiveCondition_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.CompareParam
// (Native, Public)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::CompareParam(class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.CompareParam");

	UTriggerCondition_Task_CompareParam_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Task.ActiveCondition
// (Native, Public)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_Task::ActiveCondition(class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Task.ActiveCondition");

	UTriggerCondition_Task_ActiveCondition_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_CollectItem.SetCollectConditionParam
// (Final, Native, Public)
// Parameters:
// struct FString                 InParams                       (Parm, ZeroConstructor)

void UTriggerCondition_CollectItem::SetCollectConditionParam(const struct FString& InParams)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_CollectItem.SetCollectConditionParam");

	UTriggerCondition_CollectItem_SetCollectConditionParam_Params params;
	params.InParams = InParams;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetItemIDFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            outItemID                      (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_CollectItem::GetItemIDFromData(class UVariableSet* InDataSource, int* outItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetItemIDFromData");

	UTriggerCondition_CollectItem_GetItemIDFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outItemID != nullptr)
		*outItemID = params.outItemID;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetItemCountFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            outItemCount                   (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_CollectItem::GetItemCountFromData(class UVariableSet* InDataSource, int* outItemCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetItemCountFromData");

	UTriggerCondition_CollectItem_GetItemCountFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outItemCount != nullptr)
		*outItemCount = params.outItemCount;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetCollectProcess
// (Final, Native, Public)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UTriggerCondition_CollectItem::GetCollectProcess()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_CollectItem.GetCollectProcess");

	UTriggerCondition_CollectItem_GetCollectProcess_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_GameMode.SetGameModeType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGameModeType                  GameModeType                   (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_GameMode::SetGameModeType(EGameModeType GameModeType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_GameMode.SetGameModeType");

	UTriggerCondition_GameMode_SetGameModeType_Params params;
	params.GameModeType = GameModeType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_KillPlayer.UpdateTaskProcess
// (Final, Native, Public)

void UTriggerCondition_KillPlayer::UpdateTaskProcess()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_KillPlayer.UpdateTaskProcess");

	UTriggerCondition_KillPlayer_UpdateTaskProcess_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_KillPlayer.GetKillCountFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            outKillCount                   (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_KillPlayer::GetKillCountFromData(class UVariableSet* InDataSource, int* outKillCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_KillPlayer.GetKillCountFromData");

	UTriggerCondition_KillPlayer_GetKillCountFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outKillCount != nullptr)
		*outKillCount = params.outKillCount;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_Operator.AddChildCondition
// (Final, Native, Public)
// Parameters:
// class UTriggerCondition*       NewChildCond                   (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_Operator::AddChildCondition(class UTriggerCondition* NewChildCond)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_Operator.AddChildCondition");

	UTriggerCondition_Operator_AddChildCondition_Params params;
	params.NewChildCond = NewChildCond;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedArea.SetTriggerAreaType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETaskTriggerAreaType> TriggerAreaType                (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_SpecifiedArea::SetTriggerAreaType(TEnumAsByte<ETaskTriggerAreaType> TriggerAreaType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedArea.SetTriggerAreaType");

	UTriggerCondition_SpecifiedArea_SetTriggerAreaType_Params params;
	params.TriggerAreaType = TriggerAreaType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedArea.GetTriggerAreaTypeFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETaskTriggerAreaType> outTriggerAreaType             (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_SpecifiedArea::GetTriggerAreaTypeFromData(class UVariableSet* InDataSource, TEnumAsByte<ETaskTriggerAreaType>* outTriggerAreaType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedArea.GetTriggerAreaTypeFromData");

	UTriggerCondition_SpecifiedArea_GetTriggerAreaTypeFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outTriggerAreaType != nullptr)
		*outTriggerAreaType = params.outTriggerAreaType;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedItem.SetSpecifiedItemID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_SpecifiedItem::SetSpecifiedItemID(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedItem.SetSpecifiedItemID");

	UTriggerCondition_SpecifiedItem_SetSpecifiedItemID_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedItem.GetItemIDFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            outItemID                      (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_SpecifiedItem::GetItemIDFromData(class UVariableSet* InDataSource, int* outItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedItem.GetItemIDFromData");

	UTriggerCondition_SpecifiedItem_GetItemIDFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outItemID != nullptr)
		*outItemID = params.outItemID;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedPlace.SetTriggerItemType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETaskTriggerItemType> TriggerItemType                (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_SpecifiedPlace::SetTriggerItemType(TEnumAsByte<ETaskTriggerItemType> TriggerItemType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedPlace.SetTriggerItemType");

	UTriggerCondition_SpecifiedPlace_SetTriggerItemType_Params params;
	params.TriggerItemType = TriggerItemType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerCondition_SpecifiedPlace.GetTriggerItemTypeFromData
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ETaskTriggerItemType> outTriggerItemType             (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UTriggerCondition_SpecifiedPlace::GetTriggerItemTypeFromData(class UVariableSet* InDataSource, TEnumAsByte<ETaskTriggerItemType>* outTriggerItemType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_SpecifiedPlace.GetTriggerItemTypeFromData");

	UTriggerCondition_SpecifiedPlace_GetTriggerItemTypeFromData_Params params;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (outTriggerItemType != nullptr)
		*outTriggerItemType = params.outTriggerItemType;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerCondition_TeamAction.SetTeamActionConditionType
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<ETaskTeamActionConditionType> ActionConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeIntervalForSameEmote       (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerCondition_TeamAction::SetTeamActionConditionType(TEnumAsByte<ETaskTeamActionConditionType> ActionConditionType, float TimeIntervalForSameEmote)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerCondition_TeamAction.SetTeamActionConditionType");

	UTriggerCondition_TeamAction_SetTeamActionConditionType_Params params;
	params.ActionConditionType = ActionConditionType;
	params.TimeIntervalForSameEmote = TimeIntervalForSameEmote;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerEvent_Task.BroadCast
// (Native, Public)
// Parameters:
// int                            Param                          (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerEvent_Task::BroadCast(int Param)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerEvent_Task.BroadCast");

	UTriggerEvent_Task_BroadCast_Params params;
	params.Param = Param;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_CommonAreaComponent.OnTriggerExit
// (Native, Public)
// Parameters:
// class UPrimitiveComponent*     OverlappedComponent            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)

void UTriggerItem_CommonAreaComponent::OnTriggerExit(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_CommonAreaComponent.OnTriggerExit");

	UTriggerItem_CommonAreaComponent_OnTriggerExit_Params params;
	params.OverlappedComponent = OverlappedComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_CommonAreaComponent.OnTriggerEnter
// (Native, Public, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     OverlappedComponent            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UTriggerItem_CommonAreaComponent::OnTriggerEnter(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_CommonAreaComponent.OnTriggerEnter");

	UTriggerItem_CommonAreaComponent_OnTriggerEnter_Params params;
	params.OverlappedComponent = OverlappedComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnTriggerExit
// (Final, Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATriggerItem_DrivingCheckPoint::OnTriggerExit(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnTriggerExit");

	ATriggerItem_DrivingCheckPoint_OnTriggerExit_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnTriggerEnter
// (Final, Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATriggerItem_DrivingCheckPoint::OnTriggerEnter(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnTriggerEnter");

	ATriggerItem_DrivingCheckPoint_OnTriggerEnter_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnRep_ChangeShow
// (Final, Native, Public)

void ATriggerItem_DrivingCheckPoint::OnRep_ChangeShow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.OnRep_ChangeShow");

	ATriggerItem_DrivingCheckPoint_OnRep_ChangeShow_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.IsActive
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool ATriggerItem_DrivingCheckPoint::IsActive()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.IsActive");

	ATriggerItem_DrivingCheckPoint_IsActive_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.Deactivate
// (Final, Native, Public)

void ATriggerItem_DrivingCheckPoint::Deactivate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.Deactivate");

	ATriggerItem_DrivingCheckPoint_Deactivate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.Activate
// (Final, Native, Public)

void ATriggerItem_DrivingCheckPoint::Activate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_DrivingCheckPoint.Activate");

	ATriggerItem_DrivingCheckPoint_Activate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_Task.OnTriggerExit
// (Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATriggerItem_Task::OnTriggerExit(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_Task.OnTriggerExit");

	ATriggerItem_Task_OnTriggerExit_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_Task.OnTriggerEnter
// (Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void ATriggerItem_Task::OnTriggerEnter(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_Task.OnTriggerEnter");

	ATriggerItem_Task_OnTriggerEnter_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_TriggerClock.Stop
// (Final, Native, Protected)

void ATriggerItem_TriggerClock::Stop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_TriggerClock.Stop");

	ATriggerItem_TriggerClock_Stop_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_TriggerClock.Start
// (Final, Native, Public)

void ATriggerItem_TriggerClock::Start()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_TriggerClock.Start");

	ATriggerItem_TriggerClock_Start_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TriggerItem_TriggerClock.OnTime
// (Final, Native, Protected)

void ATriggerItem_TriggerClock::OnTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TriggerItem_TriggerClock.OnTime");

	ATriggerItem_TriggerClock_OnTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.TurnAroundViewComponent.OnRep_FocustTurnTargetChange
// (Final, Native, Public)

void UTurnAroundViewComponent::OnRep_FocustTurnTargetChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.TurnAroundViewComponent.OnRep_FocustTurnTargetChange");

	UTurnAroundViewComponent_OnRep_FocustTurnTargetChange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAEBaseSkill.OnEvent
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EUTSkillEventType> TheEventType                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool AUAEBaseSkill::OnEvent(TEnumAsByte<EUTSkillEventType> TheEventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEBaseSkill.OnEvent");

	AUAEBaseSkill_OnEvent_Params params;
	params.TheEventType = TheEventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAEAvatarDisplayDirector.UnloadWeatherLevel
// (Final, Native, Public, BlueprintCallable)

void AUAEAvatarDisplayDirector::UnloadWeatherLevel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEAvatarDisplayDirector.UnloadWeatherLevel");

	AUAEAvatarDisplayDirector_UnloadWeatherLevel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SpawnAvatar
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AUAEAvatarDisplayDirector::SpawnAvatar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SpawnAvatar");

	AUAEAvatarDisplayDirector_SpawnAvatar_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SetMainCamera
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ACameraActor*            Camera                         (Parm, ZeroConstructor, IsPlainOldData)

void AUAEAvatarDisplayDirector::SetMainCamera(class ACameraActor* Camera)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SetMainCamera");

	AUAEAvatarDisplayDirector_SetMainCamera_Params params;
	params.Camera = Camera;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SendScreenPosEvent
// (Final, Native, Public, BlueprintCallable)

void AUAEAvatarDisplayDirector::SendScreenPosEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEAvatarDisplayDirector.SendScreenPosEvent");

	AUAEAvatarDisplayDirector_SendScreenPosEvent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAEAvatarDisplayDirector.CalcCharacterScreenPos
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            pos                            (Parm, ZeroConstructor, IsPlainOldData)
// class UCharacterAvatarComponent* CharComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void AUAEAvatarDisplayDirector::CalcCharacterScreenPos(int pos, class UCharacterAvatarComponent* CharComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAEAvatarDisplayDirector.CalcCharacterScreenPos");

	AUAEAvatarDisplayDirector_CalcCharacterScreenPos_Params params;
	params.pos = pos;
	params.CharComp = CharComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkill.DelayLeaveStateForMelee
// (Final, Native, Public)

void AUAESkill::DelayLeaveStateForMelee()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkill.DelayLeaveStateForMelee");

	AUAESkill_DelayLeaveStateForMelee_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_CameraShake.DumpAllCameraShakes
// (Final, Native, Static, Protected, BlueprintCallable)
// Parameters:
// class APlayerController*       PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillAction_CameraShake::DumpAllCameraShakes(class APlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_CameraShake.DumpAllCameraShakes");

	UUAESkillAction_CameraShake_DumpAllCameraShakes_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.UndoAction
// (Native, Public)

void UUAESkillAction_LaunchToxicGrnd::UndoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.UndoAction");

	UUAESkillAction_LaunchToxicGrnd_UndoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.OnSplineDestroyed
// (Native, Public)
// Parameters:
// class AActor*                  DestroyedActor                 (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillAction_LaunchToxicGrnd::OnSplineDestroyed(class AActor* DestroyedActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.OnSplineDestroyed");

	UUAESkillAction_LaunchToxicGrnd_OnSplineDestroyed_Params params;
	params.DestroyedActor = DestroyedActor;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.OnCollisionHit
// (Final, Native, Public)

void UUAESkillAction_LaunchToxicGrnd::OnCollisionHit()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.OnCollisionHit");

	UUAESkillAction_LaunchToxicGrnd_OnCollisionHit_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.BoardcastEvent
// (Native, Public)
// Parameters:
// TEnumAsByte<EUTSkillEventType> _event                         (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillAction_LaunchToxicGrnd::BoardcastEvent(TEnumAsByte<EUTSkillEventType> _event)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_LaunchToxicGrnd.BoardcastEvent");

	UUAESkillAction_LaunchToxicGrnd_BoardcastEvent_Params params;
	params._event = _event;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_MovementMode.UndoAction
// (Native, Public)

void UUAESkillAction_MovementMode::UndoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_MovementMode.UndoAction");

	UUAESkillAction_MovementMode_UndoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_MovementMode.RealDoAction
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUAESkillAction_MovementMode::RealDoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_MovementMode.RealDoAction");

	UUAESkillAction_MovementMode_RealDoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAESkillAction_PauseAnims.ResetAnimationFrame
// (Native, Public)

void UUAESkillAction_PauseAnims::ResetAnimationFrame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_PauseAnims.ResetAnimationFrame");

	UUAESkillAction_PauseAnims_ResetAnimationFrame_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillAction_ShowPromptAdvanced.GetPromptParameters
// (Event, Protected, HasOutParms, BlueprintEvent, Const)
// Parameters:
// int                            OutID                          (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// struct FString                 OutParam1                      (Parm, OutParm, ZeroConstructor)
// struct FString                 OutParam2                      (Parm, OutParm, ZeroConstructor)

void UUAESkillAction_ShowPromptAdvanced::GetPromptParameters(int* OutID, struct FString* OutParam1, struct FString* OutParam2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_ShowPromptAdvanced.GetPromptParameters");

	UUAESkillAction_ShowPromptAdvanced_GetPromptParameters_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutID != nullptr)
		*OutID = params.OutID;
	if (OutParam1 != nullptr)
		*OutParam1 = params.OutParam1;
	if (OutParam2 != nullptr)
		*OutParam2 = params.OutParam2;
}


// Function ShadowTrackerExtra.UAESkillAction_ShowPromptAdvanced.GetActionOwnerPawn
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APawn* UUAESkillAction_ShowPromptAdvanced::GetActionOwnerPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillAction_ShowPromptAdvanced.GetActionOwnerPawn");

	UUAESkillAction_ShowPromptAdvanced_GetActionOwnerPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAESkillInterface.TriggerEntryEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// EUTSkillEntry                  EntryEvent                     (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillInterface::TriggerEntryEvent(EUTSkillEntry EntryEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillInterface.TriggerEntryEvent");

	UUAESkillInterface_TriggerEntryEvent_Params params;
	params.EntryEvent = EntryEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillInterface.TriggerCustomEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// TEnumAsByte<EUAESkillEvent>    EventType                      (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillInterface::TriggerCustomEvent(TEnumAsByte<EUAESkillEvent> EventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillInterface.TriggerCustomEvent");

	UUAESkillInterface_TriggerCustomEvent_Params params;
	params.EventType = EventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillInterface.InitFromSkill
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AUAEBaseSkill*           SkillOwner                     (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillInterface::InitFromSkill(class AUAEBaseSkill* SkillOwner)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillInterface.InitFromSkill");

	UUAESkillInterface_InitFromSkill_Params params;
	params.SkillOwner = SkillOwner;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillManagerComponent.TriggerEvent
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            SkillID                        (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EUTSkillEventType> EventType                      (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillManagerComponent::TriggerEvent(int SkillID, TEnumAsByte<EUTSkillEventType> EventType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillManagerComponent.TriggerEvent");

	UUAESkillManagerComponent_TriggerEvent_Params params;
	params.SkillID = SkillID;
	params.EventType = EventType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillManagerComponent.TriggerCurSkillEvent
// (Native, Public, BlueprintCallable)
// Parameters:
// TEnumAsByte<EUAESkillEvent>    UAEEvent                       (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillManagerComponent::TriggerCurSkillEvent(TEnumAsByte<EUAESkillEvent> UAEEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillManagerComponent.TriggerCurSkillEvent");

	UUAESkillManagerComponent_TriggerCurSkillEvent_Params params;
	params.UAEEvent = UAEEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillManagerComponent.SetSkillOwner
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   Pawn                           (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillManagerComponent::SetSkillOwner(class APawn* Pawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillManagerComponent.SetSkillOwner");

	UUAESkillManagerComponent_SetSkillOwner_Params params;
	params.Pawn = Pawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillManagerComponent.ServerTriggerCurSkillEvent
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// TEnumAsByte<EUAESkillEvent>    UAEEvent                       (Parm, ZeroConstructor, IsPlainOldData)

void UUAESkillManagerComponent::ServerTriggerCurSkillEvent(TEnumAsByte<EUAESkillEvent> UAEEvent)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillManagerComponent.ServerTriggerCurSkillEvent");

	UUAESkillManagerComponent_ServerTriggerCurSkillEvent_Params params;
	params.UAEEvent = UAEEvent;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAESkillManagerComponent.GetSkillByEntry
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EUTSkillEntry                  Entry                          (Parm, ZeroConstructor, IsPlainOldData)
// class AUTSkill*                ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AUTSkill* UUAESkillManagerComponent::GetSkillByEntry(EUTSkillEntry Entry)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAESkillManagerComponent.GetSkillByEntry");

	UUAESkillManagerComponent_GetSkillByEntry_Params params;
	params.Entry = Entry;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.RestartPlayer
// (Final, Native, Static, Public)
// Parameters:
// int                            PlayerKey                      (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerParamLibrary::RestartPlayer(int PlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.RestartPlayer");

	UUAETriggerParamLibrary_RestartPlayer_Params params;
	params.PlayerKey = PlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.GetLastKiller
// (Final, Native, Static, Public)
// Parameters:
// struct FString                 ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

struct FString UUAETriggerParamLibrary::GetLastKiller()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.GetLastKiller");

	UUAETriggerParamLibrary_GetLastKiller_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.GetInt32_3
// (Final, Native, Static, Public)
// Parameters:
// int                            Param1                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Param2                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UUAETriggerParamLibrary::GetInt32_3(int Param1, int Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.GetInt32_3");

	UUAETriggerParamLibrary_GetInt32_3_Params params;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.GetInt32_2
// (Final, Native, Static, Public)
// Parameters:
// int                            Param1                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UUAETriggerParamLibrary::GetInt32_2(int Param1)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.GetInt32_2");

	UUAETriggerParamLibrary_GetInt32_2_Params params;
	params.Param1 = Param1;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.GetFloat_3
// (Final, Native, Static, Public)
// Parameters:
// float                          Param1                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          Param2                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UUAETriggerParamLibrary::GetFloat_3(float Param1, float Param2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.GetFloat_3");

	UUAETriggerParamLibrary_GetFloat_3_Params params;
	params.Param1 = Param1;
	params.Param2 = Param2;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerParamLibrary.GetFloat_2
// (Final, Native, Static, Public)
// Parameters:
// float                          Param1                         (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UUAETriggerParamLibrary::GetFloat_2(float Param1)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerParamLibrary.GetFloat_2");

	UUAETriggerParamLibrary_GetFloat_2_Params params;
	params.Param1 = Param1;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_UseItem
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// int                            ID                             (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 InVec                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UUAETriggerEventLibrary::EventFunc_UseItem(int ID, const struct FVector& InVec)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_UseItem");

	UUAETriggerEventLibrary_EventFunc_UseItem_Params params;
	params.ID = ID;
	params.InVec = InVec;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_TestEvent2
// (Event, Public, BlueprintEvent)
// Parameters:
// struct FString                 P1                             (Parm, ZeroConstructor)
// float                          P2                             (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerEventLibrary::EventFunc_TestEvent2(const struct FString& P1, float P2)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_TestEvent2");

	UUAETriggerEventLibrary_EventFunc_TestEvent2_Params params;
	params.P1 = P1;
	params.P2 = P2;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_TakePlane
// (Final, Native, Public)
// Parameters:
// uint32_t                       PlayerKey                      (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerEventLibrary::EventFunc_TakePlane(uint32_t PlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_TakePlane");

	UUAETriggerEventLibrary_EventFunc_TakePlane_Params params;
	params.PlayerKey = PlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_SpawnActor
// (Event, Public, BlueprintEvent)
// Parameters:
// class AActor*                  SpawnedActor                   (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerEventLibrary::EventFunc_SpawnActor(class AActor* SpawnedActor)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_SpawnActor");

	UUAETriggerEventLibrary_EventFunc_SpawnActor_Params params;
	params.SpawnedActor = SpawnedActor;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_PawnGenerate
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
// Parameters:
// int                            threatenValue                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 InVec                          (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UUAETriggerEventLibrary::EventFunc_PawnGenerate(int threatenValue, const struct FVector& InVec)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerEventLibrary.EventFunc_PawnGenerate");

	UUAETriggerEventLibrary_EventFunc_PawnGenerate_Params params;
	params.threatenValue = threatenValue;
	params.InVec = InVec;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.SetTaskProcess
// (Native, Public)
// Parameters:
// int                            process                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 ext_info                       (Parm, ZeroConstructor)

void UUAETriggerObject_Task::SetTaskProcess(int process, const struct FString& ext_info)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.SetTaskProcess");

	UUAETriggerObject_Task_SetTaskProcess_Params params;
	params.process = process;
	params.ext_info = ext_info;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.RedoAction
// (Native, Public)

void UUAETriggerObject_Task::RedoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.RedoAction");

	UUAETriggerObject_Task_RedoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.NofityTriggerComplete
// (Native, Protected)

void UUAETriggerObject_Task::NofityTriggerComplete()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.NofityTriggerComplete");

	UUAETriggerObject_Task_NofityTriggerComplete_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.IsConditionsSatisfy
// (Native, Protected)
// Parameters:
// class UTriggerEvent*           Event                          (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUAETriggerObject_Task::IsConditionsSatisfy(class UTriggerEvent* Event)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.IsConditionsSatisfy");

	UUAETriggerObject_Task_IsConditionsSatisfy_Params params;
	params.Event = Event;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.InitConfigurableCondition
// (Final, Native, Public)
// Parameters:
// int                            InTaskSubType                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 InMainConditionParamStr        (Parm, ZeroConstructor)
// int                            InTargetProcess                (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerObject_Task::InitConfigurableCondition(int InTaskSubType, const struct FString& InMainConditionParamStr, int InTargetProcess)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.InitConfigurableCondition");

	UUAETriggerObject_Task_InitConfigurableCondition_Params params;
	params.InTaskSubType = InTaskSubType;
	params.InMainConditionParamStr = InMainConditionParamStr;
	params.InTargetProcess = InTargetProcess;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.DeactiveCondition
// (Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> InTaskConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)

void UUAETriggerObject_Task::DeactiveCondition(TEnumAsByte<ETaskConditionType> InTaskConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.DeactiveCondition");

	UUAETriggerObject_Task_DeactiveCondition_Params params;
	params.InTaskConditionType = InTaskConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateTeamActionCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ETaskTeamActionConditionType> TeamActionConType              (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeIntervalForSameEmote       (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateTeamActionCondition(TEnumAsByte<ETaskTeamActionConditionType> TeamActionConType, float TimeIntervalForSameEmote)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateTeamActionCondition");

	UUAETriggerObject_Task_CreateTeamActionCondition_Params params;
	params.TeamActionConType = TeamActionConType;
	params.TimeIntervalForSameEmote = TimeIntervalForSameEmote;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedSpaceCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ETaskTriggerItemType> SpecifiedSpace                 (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateSpecifiedSpaceCondition(TEnumAsByte<ETaskTriggerItemType> SpecifiedSpace)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedSpaceCondition");

	UUAETriggerObject_Task_CreateSpecifiedSpaceCondition_Params params;
	params.SpecifiedSpace = SpecifiedSpace;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedItemCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateSpecifiedItemCondition(int ItemID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedItemCondition");

	UUAETriggerObject_Task_CreateSpecifiedItemCondition_Params params;
	params.ItemID = ItemID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedAreaCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TEnumAsByte<ETaskTriggerAreaType> SpecifiedArea                  (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateSpecifiedAreaCondition(TEnumAsByte<ETaskTriggerAreaType> SpecifiedArea)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateSpecifiedAreaCondition");

	UUAETriggerObject_Task_CreateSpecifiedAreaCondition_Params params;
	params.SpecifiedArea = SpecifiedArea;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateRedoAction
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskActionType>   ActionType                     (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerAction*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerAction* UUAETriggerObject_Task::CreateRedoAction(TEnumAsByte<ETaskActionType> ActionType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateRedoAction");

	UUAETriggerObject_Task_CreateRedoAction_Params params;
	params.ActionType = ActionType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateORCondition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<class UTriggerCondition*> ChildConditions                (Parm, ZeroConstructor)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateORCondition(TArray<class UTriggerCondition*> ChildConditions)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateORCondition");

	UUAETriggerObject_Task_CreateORCondition_Params params;
	params.ChildConditions = ChildConditions;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateOperatorCondition
// (Final, Native, Public)
// Parameters:
// class UClass*                  OperatorClass                  (Parm, ZeroConstructor, IsPlainOldData)
// TArray<class UTriggerCondition*> ChildConditions                (Parm, ZeroConstructor)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateOperatorCondition(class UClass* OperatorClass, TArray<class UTriggerCondition*> ChildConditions)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateOperatorCondition");

	UUAETriggerObject_Task_CreateOperatorCondition_Params params;
	params.OperatorClass = OperatorClass;
	params.ChildConditions = ChildConditions;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateKillPlayerCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateKillPlayerCondition()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateKillPlayerCondition");

	UUAETriggerObject_Task_CreateKillPlayerCondition_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateGameModeCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EGameModeType                  GameModeType                   (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateGameModeCondition(EGameModeType GameModeType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateGameModeCondition");

	UUAETriggerObject_Task_CreateGameModeCondition_Params params;
	params.GameModeType = GameModeType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateDoAction
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskActionType>   ActionType                     (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerAction*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerAction* UUAETriggerObject_Task::CreateDoAction(TEnumAsByte<ETaskActionType> ActionType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateDoAction");

	UUAETriggerObject_Task_CreateDoAction_Params params;
	params.ActionType = ActionType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateCondition
// (Final, Native, Public)
// Parameters:
// class UClass*                  ConditionClass                 (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateCondition(class UClass* ConditionClass)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateCondition");

	UUAETriggerObject_Task_CreateCondition_Params params;
	params.ConditionClass = ConditionClass;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateCollectItemCondition
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            CollectCount                   (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateCollectItemCondition(int ItemID, int CollectCount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateCollectItemCondition");

	UUAETriggerObject_Task_CreateCollectItemCondition_Params params;
	params.ItemID = ItemID;
	params.CollectCount = CollectCount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateANDCondition
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<class UTriggerCondition*> ChildConditions                (Parm, ZeroConstructor)
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::CreateANDCondition(TArray<class UTriggerCondition*> ChildConditions)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateANDCondition");

	UUAETriggerObject_Task_CreateANDCondition_Params params;
	params.ChildConditions = ChildConditions;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.CreateAction
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ETaskActionType>   ActionType                     (Parm, ZeroConstructor, IsPlainOldData)
// class UTriggerAction*          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerAction* UUAETriggerObject_Task::CreateAction(TEnumAsByte<ETaskActionType> ActionType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.CreateAction");

	UUAETriggerObject_Task_CreateAction_Params params;
	params.ActionType = ActionType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructTask
// (Final, Native, Public)
// Parameters:
// int                            InTaskID                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            InTaskSubType                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 InMainConditionParamStr        (Parm, ZeroConstructor)
// int                            InTargetProcess                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUAETriggerObject_Task::ConstructTask(int InTaskID, int InTaskSubType, const struct FString& InMainConditionParamStr, int InTargetProcess)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructTask");

	UUAETriggerObject_Task_ConstructTask_Params params;
	params.InTaskID = InTaskID;
	params.InTaskSubType = InTaskSubType;
	params.InMainConditionParamStr = InMainConditionParamStr;
	params.InTargetProcess = InTargetProcess;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructRedoActions
// (Event, Public, BlueprintEvent)
// Parameters:
// TArray<TEnumAsByte<ETaskActionType>> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<TEnumAsByte<ETaskActionType>> UUAETriggerObject_Task::ConstructRedoActions()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructRedoActions");

	UUAETriggerObject_Task_ConstructRedoActions_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructEvents
// (Event, Public, BlueprintEvent)
// Parameters:
// TArray<TEnumAsByte<ETaskEventType>> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<TEnumAsByte<ETaskEventType>> UUAETriggerObject_Task::ConstructEvents()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructEvents");

	UUAETriggerObject_Task_ConstructEvents_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructConditions
// (Event, Public, BlueprintEvent)
// Parameters:
// class UTriggerCondition*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UTriggerCondition* UUAETriggerObject_Task::ConstructConditions()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructConditions");

	UUAETriggerObject_Task_ConstructConditions_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructActions
// (Event, Public, BlueprintEvent)
// Parameters:
// TArray<TEnumAsByte<ETaskActionType>> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<TEnumAsByte<ETaskActionType>> UUAETriggerObject_Task::ConstructActions()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ConstructActions");

	UUAETriggerObject_Task_ConstructActions_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.AddEventTypes
// (Final, Native, Public)
// Parameters:
// TArray<TEnumAsByte<ETaskEventType>> EventTypes                     (Parm, ZeroConstructor)

void UUAETriggerObject_Task::AddEventTypes(TArray<TEnumAsByte<ETaskEventType>> EventTypes)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.AddEventTypes");

	UUAETriggerObject_Task_AddEventTypes_Params params;
	params.EventTypes = EventTypes;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_Task.ActiveCondition
// (Native, Public)
// Parameters:
// TEnumAsByte<ETaskConditionType> InTaskConditionType            (Parm, ZeroConstructor, IsPlainOldData)
// class UVariableSet*            InDataSource                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUAETriggerObject_Task::ActiveCondition(TEnumAsByte<ETaskConditionType> InTaskConditionType, class UVariableSet* InDataSource)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_Task.ActiveCondition");

	UUAETriggerObject_Task_ActiveCondition_Params params;
	params.InTaskConditionType = InTaskConditionType;
	params.InDataSource = InDataSource;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UAETriggerObject_CollectItem.ReportTaskCollectionProcess
// (Final, Native, Public)

void UUAETriggerObject_CollectItem::ReportTaskCollectionProcess()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_CollectItem.ReportTaskCollectionProcess");

	UUAETriggerObject_CollectItem_ReportTaskCollectionProcess_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UAETriggerObject_CollectItem.GetTaskCollectionProcess
// (Final, Native, Public)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UUAETriggerObject_CollectItem::GetTaskCollectionProcess()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UAETriggerObject_CollectItem.GetTaskCollectionProcess");

	UUAETriggerObject_CollectItem_GetTaskCollectionProcess_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerPredictHealthUI
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::UpdatePlayerPredictHealthUI(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerPredictHealthUI");

	UUIDataProcessingFunctionLibrary_UpdatePlayerPredictHealthUI_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerHealthUI
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::UpdatePlayerHealthUI(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerHealthUI");

	UUIDataProcessingFunctionLibrary_UpdatePlayerHealthUI_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerEnergyUI
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::UpdatePlayerEnergyUI(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerEnergyUI");

	UUIDataProcessingFunctionLibrary_UpdatePlayerEnergyUI_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerDyingHealth
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::UpdatePlayerDyingHealth(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerDyingHealth");

	UUIDataProcessingFunctionLibrary_UpdatePlayerDyingHealth_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerBreathAmmount
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::UpdatePlayerBreathAmmount(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UpdatePlayerBreathAmmount");

	UUIDataProcessingFunctionLibrary_UpdatePlayerBreathAmmount_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UILibraryInstance
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UUIDataProcessingFunctionLibrary* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UUIDataProcessingFunctionLibrary* UUIDataProcessingFunctionLibrary::UILibraryInstance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.UILibraryInstance");

	UUIDataProcessingFunctionLibrary_UILibraryInstance_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SortGrenadeItemArray
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FComparableGrenadeItemType> GrenadeArray                   (Parm, ZeroConstructor)
// class ASTExtraBaseCharacter*   PlayerCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// int                            CurListFirstID                 (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FComparableGrenadeItemType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FComparableGrenadeItemType> UUIDataProcessingFunctionLibrary::SortGrenadeItemArray(TArray<struct FComparableGrenadeItemType> GrenadeArray, class ASTExtraBaseCharacter* PlayerCharacter, int CurListFirstID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SortGrenadeItemArray");

	UUIDataProcessingFunctionLibrary_SortGrenadeItemArray_Params params;
	params.GrenadeArray = GrenadeArray;
	params.PlayerCharacter = PlayerCharacter;
	params.CurListFirstID = CurListFirstID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SortConsumableItemArray
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FCompatableComsumableItemType> ConsumableArray                (Parm, ZeroConstructor)
// bool                           IgnoreFirst                    (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EConsumeItemType>  FirstItemType                  (Parm, ZeroConstructor, IsPlainOldData)
// TArray<struct FCompatableComsumableItemType> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<struct FCompatableComsumableItemType> UUIDataProcessingFunctionLibrary::SortConsumableItemArray(TArray<struct FCompatableComsumableItemType> ConsumableArray, bool IgnoreFirst, TEnumAsByte<EConsumeItemType> FirstItemType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SortConsumableItemArray");

	UUIDataProcessingFunctionLibrary_SortConsumableItemArray_Params params;
	params.ConsumableArray = ConsumableArray;
	params.IgnoreFirst = IgnoreFirst;
	params.FirstItemType = FirstItemType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SetUnitPosAndOpacityAndSize
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UPanelWidget*            GPanel                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class UBorder*                 BBorder                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector2D               Scale                          (Parm, IsPlainOldData)
// float                          Opacity                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector2D               OffsetVector                   (Parm, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::SetUnitPosAndOpacityAndSize(class UPanelWidget* GPanel, class UBorder* BBorder, const struct FVector2D& Scale, float Opacity, const struct FVector2D& OffsetVector)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SetUnitPosAndOpacityAndSize");

	UUIDataProcessingFunctionLibrary_SetUnitPosAndOpacityAndSize_Params params;
	params.GPanel = GPanel;
	params.BBorder = BBorder;
	params.Scale = Scale;
	params.Opacity = Opacity;
	params.OffsetVector = OffsetVector;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SetInGameUIUserWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUAEUserWidget*          UserWidget                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::SetInGameUIUserWidget(class UUAEUserWidget* UserWidget)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.SetInGameUIUserWidget");

	UUIDataProcessingFunctionLibrary_SetInGameUIUserWidget_Params params;
	params.UserWidget = UserWidget;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.IsPlayerCanDoSprintOperation
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class ASTExtraPlayerCharacter* Player                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUIDataProcessingFunctionLibrary::IsPlayerCanDoSprintOperation(class ASTExtraPlayerCharacter* Player)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.IsPlayerCanDoSprintOperation");

	UUIDataProcessingFunctionLibrary_IsPlayerCanDoSprintOperation_Params params;
	params.Player = Player;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.IsHitPointValidInCircularHitTestPolicy
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FGeometry               MyGeometry                     (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FPointerEvent           MouseEvent                     (ConstParm, Parm, OutParm, ReferenceParm)
// float                          HitAreaRadius                  (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUIDataProcessingFunctionLibrary::IsHitPointValidInCircularHitTestPolicy(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent, float HitAreaRadius)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.IsHitPointValidInCircularHitTestPolicy");

	UUIDataProcessingFunctionLibrary_IsHitPointValidInCircularHitTestPolicy_Params params;
	params.MyGeometry = MyGeometry;
	params.MouseEvent = MouseEvent;
	params.HitAreaRadius = HitAreaRadius;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.HandleCharacterAttrChange
// (Final, Native, Public)
// Parameters:
// struct FString                 AttrName                       (Parm, ZeroConstructor)
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::HandleCharacterAttrChange(const struct FString& AttrName, class ASTExtraBaseCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.HandleCharacterAttrChange");

	UUIDataProcessingFunctionLibrary_HandleCharacterAttrChange_Params params;
	params.AttrName = AttrName;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GrenadeSpecificSlotNameToENumAdapter
// (Final, Native, Private)
// Parameters:
// struct FName                   GrenadeSpecificSlotName        (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EGrenadeType>      ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

TEnumAsByte<EGrenadeType> UUIDataProcessingFunctionLibrary::GrenadeSpecificSlotNameToENumAdapter(const struct FName& GrenadeSpecificSlotName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GrenadeSpecificSlotNameToENumAdapter");

	UUIDataProcessingFunctionLibrary_GrenadeSpecificSlotNameToENumAdapter_Params params;
	params.GrenadeSpecificSlotName = GrenadeSpecificSlotName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetServerWorldSecond
// (Final, Native, Static, Public)
// Parameters:
// class UObject*                 WorldContextObject             (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UUIDataProcessingFunctionLibrary::GetServerWorldSecond(class UObject* WorldContextObject)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetServerWorldSecond");

	UUIDataProcessingFunctionLibrary_GetServerWorldSecond_Params params;
	params.WorldContextObject = WorldContextObject;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetCurPlatformType
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UUIDataProcessingFunctionLibrary::GetCurPlatformType()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetCurPlatformType");

	UUIDataProcessingFunctionLibrary_GetCurPlatformType_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetCharacterEnergyValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                   CharaterPawn                   (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UUIDataProcessingFunctionLibrary::GetCharacterEnergyValue(class APawn* CharaterPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.GetCharacterEnergyValue");

	UUIDataProcessingFunctionLibrary_GetCharacterEnergyValue_Params params;
	params.CharaterPawn = CharaterPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.CalYearBeastHealthRatioAndRemainBarCounts
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          CurHealth                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          MaxHealth                      (Parm, ZeroConstructor, IsPlainOldData)
// float                          BossHealthPerBar               (Parm, ZeroConstructor, IsPlainOldData)
// float                          HealthRatio                    (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// float                          RemainBarCounts                (Parm, OutParm, ZeroConstructor, IsPlainOldData)

void UUIDataProcessingFunctionLibrary::CalYearBeastHealthRatioAndRemainBarCounts(float CurHealth, float MaxHealth, float BossHealthPerBar, float* HealthRatio, float* RemainBarCounts)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.CalYearBeastHealthRatioAndRemainBarCounts");

	UUIDataProcessingFunctionLibrary_CalYearBeastHealthRatioAndRemainBarCounts_Params params;
	params.CurHealth = CurHealth;
	params.MaxHealth = MaxHealth;
	params.BossHealthPerBar = BossHealthPerBar;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (HealthRatio != nullptr)
		*HealthRatio = params.HealthRatio;
	if (RemainBarCounts != nullptr)
		*RemainBarCounts = params.RemainBarCounts;
}


// Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.CalYearBeastCurProgressBarPercent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          CurHealthPercent               (Parm, ZeroConstructor, IsPlainOldData)
// float                          BossHealthPerProgressBar       (Parm, ZeroConstructor, IsPlainOldData)
// float                          RemainBarCounts                (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UUIDataProcessingFunctionLibrary::CalYearBeastCurProgressBarPercent(float CurHealthPercent, float BossHealthPerProgressBar, float RemainBarCounts)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDataProcessingFunctionLibrary.CalYearBeastCurProgressBarPercent");

	UUIDataProcessingFunctionLibrary_CalYearBeastCurProgressBarPercent_Params params;
	params.CurHealthPercent = CurHealthPercent;
	params.BossHealthPerProgressBar = BossHealthPerProgressBar;
	params.RemainBarCounts = RemainBarCounts;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.RemoveTagFromItemPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 TagName                        (Parm, ZeroConstructor)

void UUIDuplicatedItemPool::RemoveTagFromItemPool(const struct FString& TagName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.RemoveTagFromItemPool");

	UUIDuplicatedItemPool_RemoveTagFromItemPool_Params params;
	params.TagName = TagName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.RemoveAllTagFromItemPool
// (Final, Native, Public, BlueprintCallable)

void UUIDuplicatedItemPool::RemoveAllTagFromItemPool()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.RemoveAllTagFromItemPool");

	UUIDuplicatedItemPool_RemoveAllTagFromItemPool_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.RecycleUnusedItem
// (Final, Native, Public)

void UUIDuplicatedItemPool::RecycleUnusedItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.RecycleUnusedItem");

	UUIDuplicatedItemPool_RecycleUnusedItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FString                 TagName                        (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUIDuplicatedItemPool::ItemPoolHasTag(const struct FString& TagName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasTag");

	UUIDuplicatedItemPool_ItemPoolHasTag_Params params;
	params.TagName = TagName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasOneTagAtLeast
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FString>         TagNameList                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUIDuplicatedItemPool::ItemPoolHasOneTagAtLeast(TArray<struct FString> TagNameList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasOneTagAtLeast");

	UUIDuplicatedItemPool_ItemPoolHasOneTagAtLeast_Params params;
	params.TagNameList = TagNameList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasAllTag
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FString>         TagNameList                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUIDuplicatedItemPool::ItemPoolHasAllTag(TArray<struct FString> TagNameList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.ItemPoolHasAllTag");

	UUIDuplicatedItemPool_ItemPoolHasAllTag_Params params;
	params.TagNameList = TagNameList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.InitItemPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 ClassPath                      (Parm, ZeroConstructor)
// int                            DefaultItemCounts              (Parm, ZeroConstructor, IsPlainOldData)

void UUIDuplicatedItemPool::InitItemPool(const struct FString& ClassPath, int DefaultItemCounts)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.InitItemPool");

	UUIDuplicatedItemPool_InitItemPool_Params params;
	params.ClassPath = ClassPath;
	params.DefaultItemCounts = DefaultItemCounts;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.GetOneItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUserWidget*             ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UUserWidget* UUIDuplicatedItemPool::GetOneItem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.GetOneItem");

	UUIDuplicatedItemPool_GetOneItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.GetAllUsedItem
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<class UUserWidget*>     ItemList                       (Parm, OutParm, ZeroConstructor)

void UUIDuplicatedItemPool::GetAllUsedItem(TArray<class UUserWidget*>* ItemList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.GetAllUsedItem");

	UUIDuplicatedItemPool_GetAllUsedItem_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (ItemList != nullptr)
		*ItemList = params.ItemList;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.GetAllTagFromItemPool
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FString>         TagList                        (Parm, OutParm, ZeroConstructor)

void UUIDuplicatedItemPool::GetAllTagFromItemPool(TArray<struct FString>* TagList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.GetAllTagFromItemPool");

	UUIDuplicatedItemPool_GetAllTagFromItemPool_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (TagList != nullptr)
		*TagList = params.TagList;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.FreeOneItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UUserWidget*             IdleItem                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UUIDuplicatedItemPool::FreeOneItem(class UUserWidget* IdleItem)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.FreeOneItem");

	UUIDuplicatedItemPool_FreeOneItem_Params params;
	params.IdleItem = IdleItem;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.AddTagToItemPool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FString                 TagName                        (Parm, ZeroConstructor)

void UUIDuplicatedItemPool::AddTagToItemPool(const struct FString& TagName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.AddTagToItemPool");

	UUIDuplicatedItemPool_AddTagToItemPool_Params params;
	params.TagName = TagName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UIDuplicatedItemPool.AddMultiTagToItemPool
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// TArray<struct FString>         TagNameList                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)

void UUIDuplicatedItemPool::AddMultiTagToItemPool(TArray<struct FString> TagNameList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UIDuplicatedItemPool.AddMultiTagToItemPool");

	UUIDuplicatedItemPool_AddMultiTagToItemPool_Params params;
	params.TagNameList = TagNameList;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UNGCondition_IsInSomePoseForXSec.OnPlayerStateChange
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastPose                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     NewPose                        (Parm, ZeroConstructor, IsPlainOldData)

void UUNGCondition_IsInSomePoseForXSec::OnPlayerStateChange(TEnumAsByte<ESTEPoseState> LastPose, TEnumAsByte<ESTEPoseState> NewPose)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UNGCondition_IsInSomePoseForXSec.OnPlayerStateChange");

	UUNGCondition_IsInSomePoseForXSec_OnPlayerStateChange_Params params;
	params.LastPose = LastPose;
	params.NewPose = NewPose;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UserInputCache.ResetReportComplaintNames
// (Final, Native, Static, Public, BlueprintCallable)

void UUserInputCache::ResetReportComplaintNames()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UserInputCache.ResetReportComplaintNames");

	UUserInputCache_ResetReportComplaintNames_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UserInputCache.CheckIsNameReport
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReportName                     (Parm, ZeroConstructor)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUserInputCache::CheckIsNameReport(const struct FString& ReportName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UserInputCache.CheckIsNameReport");

	UUserInputCache_CheckIsNameReport_Params params;
	params.ReportName = ReportName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.UserInputCache.CacheReportComplaintName
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// struct FString                 ReportName                     (Parm, ZeroConstructor)
// bool                           IsReport                       (Parm, ZeroConstructor, IsPlainOldData)

void UUserInputCache::CacheReportComplaintName(const struct FString& ReportName, bool IsReport)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UserInputCache.CacheReportComplaintName");

	UUserInputCache_CacheReportComplaintName_Params params;
	params.ReportName = ReportName;
	params.IsReport = IsReport;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	static auto defaultObj = StaticClass()->GetDefaultObject();
	defaultObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.UndoAction
// (Native, Public)

void UUTSkillAppearance_AddParticle::UndoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.UndoAction");

	UUTSkillAppearance_AddParticle_UndoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.Reset
// (Native, Public)

void UUTSkillAppearance_AddParticle::Reset()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.Reset");

	UUTSkillAppearance_AddParticle_Reset_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.OnParticleSystemFinished
// (Final, Native, Private)
// Parameters:
// class UParticleSystemComponent* PSC                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UUTSkillAppearance_AddParticle::OnParticleSystemFinished(class UParticleSystemComponent* PSC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_AddParticle.OnParticleSystemFinished");

	UUTSkillAppearance_AddParticle_OnParticleSystemFinished_Params params;
	params.PSC = PSC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_ParticleSystem.OnHurtAppearanceParticleSystemFinished
// (Native, Public)
// Parameters:
// class UParticleSystemComponent* PSC                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UUTSkillAppearance_ParticleSystem::OnHurtAppearanceParticleSystemFinished(class UParticleSystemComponent* PSC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_ParticleSystem.OnHurtAppearanceParticleSystemFinished");

	UUTSkillAppearance_ParticleSystem_OnHurtAppearanceParticleSystemFinished_Params params;
	params.PSC = PSC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_ParticleSystem.OnAppearanceParticleSystemFinished
// (Native, Public)
// Parameters:
// class UParticleSystemComponent* PSC                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UUTSkillAppearance_ParticleSystem::OnAppearanceParticleSystemFinished(class UParticleSystemComponent* PSC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_ParticleSystem.OnAppearanceParticleSystemFinished");

	UUTSkillAppearance_ParticleSystem_OnAppearanceParticleSystemFinished_Params params;
	params.PSC = PSC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.UndoAction
// (Native, Public)

void UUTSkillAppearance_RomoveParticle::UndoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.UndoAction");

	UUTSkillAppearance_RomoveParticle_UndoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.Reset
// (Native, Public)

void UUTSkillAppearance_RomoveParticle::Reset()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.Reset");

	UUTSkillAppearance_RomoveParticle_Reset_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.RealDoAction
// (Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UUTSkillAppearance_RomoveParticle::RealDoAction()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.UTSkillAppearance_RomoveParticle.RealDoAction");

	UUTSkillAppearance_RomoveParticle_RealDoAction_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.VehicleTakeDamage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Instigator                     (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleCommonComponent::VehicleTakeDamage(float Damage, class AController* Instigator)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.VehicleTakeDamage");

	UVehicleCommonComponent_VehicleTakeDamage_Params params;
	params.Damage = Damage;
	params.Instigator = Instigator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.TakeDamageByHitPart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// unsigned char                  HitPart                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           IgnoreWheels                   (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Instigator                     (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleCommonComponent::TakeDamageByHitPart(float Damage, unsigned char HitPart, bool IgnoreWheels, class AController* Instigator)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.TakeDamageByHitPart");

	UVehicleCommonComponent_TakeDamageByHitPart_Params params;
	params.Damage = Damage;
	params.HitPart = HitPart;
	params.IgnoreWheels = IgnoreWheels;
	params.Instigator = Instigator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.TakeDamageByBoneName
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   BoneName                       (Parm, OutParm, ZeroConstructor, IsPlainOldData)
// bool                           IgnoreWheels                   (Parm, ZeroConstructor, IsPlainOldData)
// class AController*             Instigator                     (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleCommonComponent::TakeDamageByBoneName(float Damage, bool IgnoreWheels, class AController* Instigator, struct FName* BoneName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.TakeDamageByBoneName");

	UVehicleCommonComponent_TakeDamageByBoneName_Params params;
	params.Damage = Damage;
	params.IgnoreWheels = IgnoreWheels;
	params.Instigator = Instigator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (BoneName != nullptr)
		*BoneName = params.BoneName;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.RefreshWheelState
// (Final, Native, Public, BlueprintCallable)

void UVehicleCommonComponent::RefreshWheelState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.RefreshWheelState");

	UVehicleCommonComponent_RefreshWheelState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_WheelsCurrentHP
// (Final, Native, Private)

void UVehicleCommonComponent::OnRep_WheelsCurrentHP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_WheelsCurrentHP");

	UVehicleCommonComponent_OnRep_WheelsCurrentHP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_HP
// (Final, Native, Private)

void UVehicleCommonComponent::OnRep_HP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_HP");

	UVehicleCommonComponent_OnRep_HP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_Fuel
// (Final, Native, Private)

void UVehicleCommonComponent::OnRep_Fuel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.OnRep_Fuel");

	UVehicleCommonComponent_OnRep_Fuel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.NoFuel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleCommonComponent::NoFuel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.NoFuel");

	UVehicleCommonComponent_NoFuel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.IsDestroyed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleCommonComponent::IsDestroyed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.IsDestroyed");

	UVehicleCommonComponent_IsDestroyed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelsHPNum
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UVehicleCommonComponent::GetWheelsHPNum()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelsHPNum");

	UVehicleCommonComponent_GetWheelsHPNum_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelHPMax
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            WheelIdx                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetWheelHPMax(int WheelIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelHPMax");

	UVehicleCommonComponent_GetWheelHPMax_Params params;
	params.WheelIdx = WheelIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelHP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            WheelIdx                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetWheelHP(int WheelIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetWheelHP");

	UVehicleCommonComponent_GetWheelHP_Params params;
	params.WheelIdx = WheelIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetVehicleHPMax
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetVehicleHPMax()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetVehicleHPMax");

	UVehicleCommonComponent_GetVehicleHPMax_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetVehicleHP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetVehicleHP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetVehicleHP");

	UVehicleCommonComponent_GetVehicleHP_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetFuelMax
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetFuelMax()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetFuelMax");

	UVehicleCommonComponent_GetFuelMax_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetFuelConsumeFactor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetFuelConsumeFactor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetFuelConsumeFactor");

	UVehicleCommonComponent_GetFuelConsumeFactor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleCommonComponent.GetFuel
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleCommonComponent::GetFuel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleCommonComponent.GetFuel");

	UVehicleCommonComponent_GetFuel_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleDamageComponent.HandleOnVehicleHit
// (Final, Native, Protected, HasOutParms, HasDefaults)
// Parameters:
// class AActor*                  SelfActor                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVehicleDamageComponent::HandleOnVehicleHit(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleDamageComponent.HandleOnVehicleHit");

	UVehicleDamageComponent_HandleOnVehicleHit_Params params;
	params.SelfActor = SelfActor;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleMotorbikeComponent.HandleOnVehicleHit
// (Final, Native, Protected, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     HitComponent                   (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVehicleMotorbikeComponent::HandleOnVehicleHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleMotorbikeComponent.HandleOnVehicleHit");

	UVehicleMotorbikeComponent_HandleOnVehicleHit_Params params;
	params.HitComponent = HitComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSeatComponent.OnRep_Occupiers
// (Final, Native, Public)

void UVehicleSeatComponent::OnRep_Occupiers()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSeatComponent.OnRep_Occupiers");

	UVehicleSeatComponent_OnRep_Occupiers_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSeatComponent.IsSeatAvailable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleSeatComponent::IsSeatAvailable(ESTExtraVehicleSeatType SeatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSeatComponent.IsSeatAvailable");

	UVehicleSeatComponent_IsSeatAvailable_Params params;
	params.SeatType = SeatType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSeatComponent.GetDriver
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerCharacter* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerCharacter* UVehicleSeatComponent::GetDriver()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSeatComponent.GetDriver");

	UVehicleSeatComponent_GetDriver_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSeatComponent.ClientSetLeaveVehicleLocation
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 LeaveLocation                  (Parm, IsPlainOldData)

void UVehicleSeatComponent::ClientSetLeaveVehicleLocation(class ASTExtraPlayerCharacter* Character, const struct FVector& LeaveLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSeatComponent.ClientSetLeaveVehicleLocation");

	UVehicleSeatComponent_ClientSetLeaveVehicleLocation_Params params;
	params.Character = Character;
	params.LeaveLocation = LeaveLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSpringArmComponent.ForceUpdateDesiredArmLocation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bDoTrace                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bDoLocationLag                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bDoRotationLag                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSpringArmComponent::ForceUpdateDesiredArmLocation(bool bDoTrace, bool bDoLocationLag, bool bDoRotationLag, float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSpringArmComponent.ForceUpdateDesiredArmLocation");

	UVehicleSpringArmComponent_ForceUpdateDesiredArmLocation_Params params;
	params.bDoTrace = bDoTrace;
	params.bDoLocationLag = bDoLocationLag;
	params.bDoRotationLag = bDoRotationLag;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSpringArmComponent.DelayRotationLagEnabledEnd
// (Final, Native, Protected)

void UVehicleSpringArmComponent::DelayRotationLagEnabledEnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSpringArmComponent.DelayRotationLagEnabledEnd");

	UVehicleSpringArmComponent_DelayRotationLagEnabledEnd_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSpringArmComponent.DelayRotationLagEnabled
// (Final, Native, Public, HasDefaults)
// Parameters:
// bool                           bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)
// float                          Time                           (Parm, ZeroConstructor, IsPlainOldData)
// struct FRotator                _RelativeRotator               (Parm, IsPlainOldData)

void UVehicleSpringArmComponent::DelayRotationLagEnabled(bool bEnabled, float Time, const struct FRotator& _RelativeRotator)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSpringArmComponent.DelayRotationLagEnabled");

	UVehicleSpringArmComponent_DelayRotationLagEnabled_Params params;
	params.bEnabled = bEnabled;
	params.Time = Time;
	params._RelativeRotator = _RelativeRotator;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.VerifyClientTimeStamp
// (Final, Native, Public)
// Parameters:
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleSyncComponent::VerifyClientTimeStamp(float TimeStamp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.VerifyClientTimeStamp");

	UVehicleSyncComponent_VerifyClientTimeStamp_Params params;
	params.TimeStamp = TimeStamp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendServerMoveToClient
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ServerLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ServerLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ServerRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ServerAngularVelocity          (ConstParm, Parm, ReferenceParm)
// bool                           bIsSnap                        (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSyncComponent::SendServerMoveToClient(int InCorrectionId, const struct FVector_NetQuantize100& ServerLocation, const struct FVector_NetQuantize100& ServerLinearVelocity, const struct FVector_NetQuantizeNormal& ServerRotator, const struct FVector_NetQuantize100& ServerAngularVelocity, bool bIsSnap)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendServerMoveToClient");

	UVehicleSyncComponent_SendServerMoveToClient_Params params;
	params.InCorrectionId = InCorrectionId;
	params.ServerLocation = ServerLocation;
	params.ServerLinearVelocity = ServerLinearVelocity;
	params.ServerRotator = ServerRotator;
	params.ServerAngularVelocity = ServerAngularVelocity;
	params.bIsSnap = bIsSnap;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerUnreliably
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, ReferenceParm)

void UVehicleSyncComponent::SendClientMoveToServerUnreliably(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerUnreliably");

	UVehicleSyncComponent_SendClientMoveToServerUnreliably_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerReliably
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, ReferenceParm)

void UVehicleSyncComponent::SendClientMoveToServerReliably(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerReliably");

	UVehicleSyncComponent_SendClientMoveToServerReliably_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerInternal
// (Final, Native, Public, HasOutParms)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, OutParm, ReferenceParm)
// bool                           InShouldDelay                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UVehicleSyncComponent::SendClientMoveToServerInternal(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity, bool InShouldDelay)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServerInternal");

	UVehicleSyncComponent_SendClientMoveToServerInternal_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;
	params.InShouldDelay = InShouldDelay;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServer_WithDelay
// (Final, Native, Public, HasOutParms)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, OutParm, ReferenceParm)

void UVehicleSyncComponent::SendClientMoveToServer_WithDelay(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServer_WithDelay");

	UVehicleSyncComponent_SendClientMoveToServer_WithDelay_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServer_DoWork
// (Final, Native, Public, HasOutParms)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, OutParm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, OutParm, ReferenceParm)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int UVehicleSyncComponent::SendClientMoveToServer_DoWork(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientMoveToServer_DoWork");

	UVehicleSyncComponent_SendClientMoveToServer_DoWork_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientHitToServerUnreliably
// (Net, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, ReferenceParm)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  NormalImpulse                  (ConstParm, Parm, ReferenceParm)
// struct FHitResult              Hit                            (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void UVehicleSyncComponent::SendClientHitToServerUnreliably(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity, class AActor* OtherActor, const struct FVector_NetQuantize100& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientHitToServerUnreliably");

	UVehicleSyncComponent_SendClientHitToServerUnreliably_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.SendClientHitToServerReliably
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// int                            InCorrectionId                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          TimeStamp                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  ClientLocation                 (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientLinearVelocity           (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantizeNormal ClientRotator                  (ConstParm, Parm, ReferenceParm)
// struct FVector_NetQuantize100  ClientAngularVelocity          (ConstParm, Parm, ReferenceParm)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  NormalImpulse                  (ConstParm, Parm, ReferenceParm)
// struct FHitResult              Hit                            (ConstParm, Parm, ReferenceParm, IsPlainOldData)

void UVehicleSyncComponent::SendClientHitToServerReliably(int InCorrectionId, float TimeStamp, const struct FVector_NetQuantize100& ClientLocation, const struct FVector_NetQuantize100& ClientLinearVelocity, const struct FVector_NetQuantizeNormal& ClientRotator, const struct FVector_NetQuantize100& ClientAngularVelocity, class AActor* OtherActor, const struct FVector_NetQuantize100& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.SendClientHitToServerReliably");

	UVehicleSyncComponent_SendClientHitToServerReliably_Params params;
	params.InCorrectionId = InCorrectionId;
	params.TimeStamp = TimeStamp;
	params.ClientLocation = ClientLocation;
	params.ClientLinearVelocity = ClientLinearVelocity;
	params.ClientRotator = ClientRotator;
	params.ClientAngularVelocity = ClientAngularVelocity;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.OnHitAtServer
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// class AActor*                  SelfActor                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVehicleSyncComponent::OnHitAtServer(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.OnHitAtServer");

	UVehicleSyncComponent_OnHitAtServer_Params params;
	params.SelfActor = SelfActor;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.OnHitAtClient
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// class AActor*                  SelfActor                      (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVehicleSyncComponent::OnHitAtClient(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.OnHitAtClient");

	UVehicleSyncComponent_OnHitAtClient_Params params;
	params.SelfActor = SelfActor;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.OnDriverRide
// (Final, Native, Public)

void UVehicleSyncComponent::OnDriverRide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.OnDriverRide");

	UVehicleSyncComponent_OnDriverRide_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatDetached
// (Native, Public)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSyncComponent::HandleOnSeatDetached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatDetached");

	UVehicleSyncComponent_HandleOnSeatDetached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatChanged
// (Native, Public)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        LastSeatType                   (Parm, ZeroConstructor, IsPlainOldData)
// int                            LastSeatIdx                    (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        NewSeatType                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            NewSeatIdx                     (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSyncComponent::HandleOnSeatChanged(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType LastSeatType, int LastSeatIdx, ESTExtraVehicleSeatType NewSeatType, int NewSeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatChanged");

	UVehicleSyncComponent_HandleOnSeatChanged_Params params;
	params.Character = Character;
	params.LastSeatType = LastSeatType;
	params.LastSeatIdx = LastSeatIdx;
	params.NewSeatType = NewSeatType;
	params.NewSeatIdx = NewSeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatAttached
// (Native, Public)
// Parameters:
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatIdx                        (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSyncComponent::HandleOnSeatAttached(class ASTExtraPlayerCharacter* Character, ESTExtraVehicleSeatType SeatType, int SeatIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.HandleOnSeatAttached");

	UVehicleSyncComponent_HandleOnSeatAttached_Params params;
	params.Character = Character;
	params.SeatType = SeatType;
	params.SeatIdx = SeatIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.GetRiders
// (Final, Native, Public)
// Parameters:
// TArray<class ASTExtraBaseCharacter*> ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm)

TArray<class ASTExtraBaseCharacter*> UVehicleSyncComponent::GetRiders()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.GetRiders");

	UVehicleSyncComponent_GetRiders_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.GetLanscapeHeight
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FVector                 ClientLocation                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float UVehicleSyncComponent::GetLanscapeHeight(const struct FVector& ClientLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.GetLanscapeHeight");

	UVehicleSyncComponent_GetLanscapeHeight_Params params;
	params.ClientLocation = ClientLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.GetFloorPosition
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FVector                 Location                       (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// struct FVector                 OutFloorLocation               (Parm, OutParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleSyncComponent::GetFloorPosition(const struct FVector& Location, struct FVector* OutFloorLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.GetFloorPosition");

	UVehicleSyncComponent_GetFloorPosition_Params params;
	params.Location = Location;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutFloorLocation != nullptr)
		*OutFloorLocation = params.OutFloorLocation;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.DragUnderGround
// (Final, Native, Public, BlueprintCallable)

void UVehicleSyncComponent::DragUnderGround()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.DragUnderGround");

	UVehicleSyncComponent_DragUnderGround_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.Correct
// (Final, Native, Public)
// Parameters:
// bool                           bIsSnap                        (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bPlayerChannel                 (Parm, ZeroConstructor, IsPlainOldData)
// float                          ZAdjustValue                   (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleSyncComponent::Correct(bool bIsSnap, bool bPlayerChannel, float ZAdjustValue)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.Correct");

	UVehicleSyncComponent_Correct_Params params;
	params.bIsSnap = bIsSnap;
	params.bPlayerChannel = bPlayerChannel;
	params.ZAdjustValue = ZAdjustValue;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.ClientHitActor
// (Final, Native, Public, HasOutParms)
// Parameters:
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector_NetQuantize100  NormalImpulse                  (ConstParm, Parm, OutParm, ReferenceParm)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVehicleSyncComponent::ClientHitActor(class AActor* OtherActor, const struct FVector_NetQuantize100& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.ClientHitActor");

	UVehicleSyncComponent_ClientHitActor_Params params;
	params.OtherActor = OtherActor;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.CheckAndLoadLandscape
// (Final, Native, Public)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleSyncComponent::CheckAndLoadLandscape(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.CheckAndLoadLandscape");

	UVehicleSyncComponent_CheckAndLoadLandscape_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.ApplyRigidBodyState
// (Final, Native, Public, HasOutParms)
// Parameters:
// struct FRigidBodyState         NewState                       (Parm, OutParm)

void UVehicleSyncComponent::ApplyRigidBodyState(struct FRigidBodyState* NewState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.ApplyRigidBodyState");

	UVehicleSyncComponent_ApplyRigidBodyState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (NewState != nullptr)
		*NewState = params.NewState;
}


// Function ShadowTrackerExtra.VehicleSyncComponent.AdjustFloorPosition
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// struct FVector                 ClientLocation                 (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
// TArray<class ASTExtraBaseCharacter*> Riders                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
// struct FVector                 OutLocation                    (Parm, OutParm, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleSyncComponent::AdjustFloorPosition(const struct FVector& ClientLocation, TArray<class ASTExtraBaseCharacter*> Riders, struct FVector* OutLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleSyncComponent.AdjustFloorPosition");

	UVehicleSyncComponent_AdjustFloorPosition_Params params;
	params.ClientLocation = ClientLocation;
	params.Riders = Riders;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (OutLocation != nullptr)
		*OutLocation = params.OutLocation;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleTriggerComponent.OnTriggered
// (Event, Protected, BlueprintEvent)

void UVehicleTriggerComponent::OnTriggered()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleTriggerComponent.OnTriggered");

	UVehicleTriggerComponent_OnTriggered_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.UpdatePassengerViewPitchLimit
// (Final, Native, Protected)

void UVehicleUserComponent::UpdatePassengerViewPitchLimit()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.UpdatePassengerViewPitchLimit");

	UVehicleUserComponent_UpdatePassengerViewPitchLimit_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TurnVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::TurnVehicle(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TurnVehicle");

	UVehicleUserComponent_TurnVehicle_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TryUseHorn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bUse                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::TryUseHorn(bool bUse)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TryUseHorn");

	UVehicleUserComponent_TryUseHorn_Params params;
	params.bUse = bUse;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TryLeanOutOrIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bAutoLeanOut                   (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleUserComponent::TryLeanOutOrIn(bool bAutoLeanOut)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TryLeanOutOrIn");

	UVehicleUserComponent_TryLeanOutOrIn_Params params;
	params.bAutoLeanOut = bAutoLeanOut;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TryExitVehicle
// (Final, Native, Public, BlueprintCallable)

void UVehicleUserComponent::TryExitVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TryExitVehicle");

	UVehicleUserComponent_TryExitVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TryEnterVehicle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraVehicleBase*     InVehicle                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::TryEnterVehicle(class ASTExtraVehicleBase* InVehicle, ESTExtraVehicleSeatType SeatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TryEnterVehicle");

	UVehicleUserComponent_TryEnterVehicle_Params params;
	params.InVehicle = InVehicle;
	params.SeatType = SeatType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TryChangeVehicleSeat
// (Final, Native, Public, BlueprintCallable)

void UVehicleUserComponent::TryChangeVehicleSeat()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TryChangeVehicleSeat");

	UVehicleUserComponent_TryChangeVehicleSeat_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.TestForceTurnVehicle
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FRotator                Rotation                       (Parm, IsPlainOldData)
// bool                           bIsAdd                         (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::TestForceTurnVehicle(const struct FRotator& Rotation, bool bIsAdd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.TestForceTurnVehicle");

	UVehicleUserComponent_TestForceTurnVehicle_Params params;
	params.Rotation = Rotation;
	params.bIsAdd = bIsAdd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.SetBrake
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::SetBrake(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.SetBrake");

	UVehicleUserComponent_SetBrake_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.SetBoosting
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bEnabled                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::SetBoosting(bool bEnabled)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.SetBoosting");

	UVehicleUserComponent_SetBoosting_Params params;
	params.bEnabled = bEnabled;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.SetAirControlF
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::SetAirControlF(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.SetAirControlF");

	UVehicleUserComponent_SetAirControlF_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.SetAirControlB
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::SetAirControlB(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.SetAirControlB");

	UVehicleUserComponent_SetAirControlB_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.RspLeanOut
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// bool                           bOut                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::RspLeanOut(bool bOut)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.RspLeanOut");

	UVehicleUserComponent_RspLeanOut_Params params;
	params.bOut = bOut;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.RspExitVehicle
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// bool                           bSuccess                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::RspExitVehicle(bool bSuccess)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.RspExitVehicle");

	UVehicleUserComponent_RspExitVehicle_Params params;
	params.bSuccess = bSuccess;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.RspEnterVehicle
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// class ASTExtraVehicleBase*     InVehicle                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bSuccess                       (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatInd                        (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::RspEnterVehicle(class ASTExtraVehicleBase* InVehicle, bool bSuccess, ESTExtraVehicleSeatType SeatType, int SeatInd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.RspEnterVehicle");

	UVehicleUserComponent_RspEnterVehicle_Params params;
	params.InVehicle = InVehicle;
	params.bSuccess = bSuccess;
	params.SeatType = SeatType;
	params.SeatInd = SeatInd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.RspChangeVehicleSeat
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// bool                           bSuccess                       (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)
// int                            SeatInd                        (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::RspChangeVehicleSeat(bool bSuccess, ESTExtraVehicleSeatType SeatType, int SeatInd)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.RspChangeVehicleSeat");

	UVehicleUserComponent_RspChangeVehicleSeat_Params params;
	params.bSuccess = bSuccess;
	params.SeatType = SeatType;
	params.SeatInd = SeatInd;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqSyncViewTargetLastDriveInfo
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraPlayerController* ObserverController             (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraBaseCharacter*   ViewTargetCharacter            (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::ReqSyncViewTargetLastDriveInfo(class ASTExtraPlayerController* ObserverController, class ASTExtraBaseCharacter* ViewTargetCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqSyncViewTargetLastDriveInfo");

	UVehicleUserComponent_ReqSyncViewTargetLastDriveInfo_Params params;
	params.ObserverController = ObserverController;
	params.ViewTargetCharacter = ViewTargetCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqMarkLastestVehicle
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// class ASTExtraPlayerController* STEPC                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraVehicleBase*     InVehicle                      (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::ReqMarkLastestVehicle(class ASTExtraPlayerController* STEPC, class ASTExtraVehicleBase* InVehicle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqMarkLastestVehicle");

	UVehicleUserComponent_ReqMarkLastestVehicle_Params params;
	params.STEPC = STEPC;
	params.InVehicle = InVehicle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqLeanOut
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// bool                           IsLeanOut                      (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::ReqLeanOut(bool IsLeanOut)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqLeanOut");

	UVehicleUserComponent_ReqLeanOut_Params params;
	params.IsLeanOut = IsLeanOut;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqExitVehicle
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults, NetValidate)
// Parameters:
// struct FVector                 ClientVehicleVelocity          (Parm, IsPlainOldData)

void UVehicleUserComponent::ReqExitVehicle(const struct FVector& ClientVehicleVelocity)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqExitVehicle");

	UVehicleUserComponent_ReqExitVehicle_Params params;
	params.ClientVehicleVelocity = ClientVehicleVelocity;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqEraseLastDriveVehicle
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void UVehicleUserComponent::ReqEraseLastDriveVehicle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqEraseLastDriveVehicle");

	UVehicleUserComponent_ReqEraseLastDriveVehicle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqEnterVehicle
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// class ASTExtraVehicleBase*     InVehicle                      (Parm, ZeroConstructor, IsPlainOldData)
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::ReqEnterVehicle(class ASTExtraVehicleBase* InVehicle, ESTExtraVehicleSeatType SeatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqEnterVehicle");

	UVehicleUserComponent_ReqEnterVehicle_Params params;
	params.InVehicle = InVehicle;
	params.SeatType = SeatType;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ReqChangeVehicleSeat
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)

void UVehicleUserComponent::ReqChangeVehicleSeat()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ReqChangeVehicleSeat");

	UVehicleUserComponent_ReqChangeVehicleSeat_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.ProcessReconnectionData
// (Final, Native, Protected)

void UVehicleUserComponent::ProcessReconnectionData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.ProcessReconnectionData");

	UVehicleUserComponent_ProcessReconnectionData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnUpdateVehicleSpeedGUI
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                          RawSpeed                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::OnUpdateVehicleSpeedGUI(float RawSpeed)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnUpdateVehicleSpeedGUI");

	UVehicleUserComponent_OnUpdateVehicleSpeedGUI_Params params;
	params.RawSpeed = RawSpeed;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnServerAboutToReconnect
// (Final, Native, Protected)

void UVehicleUserComponent::OnServerAboutToReconnect()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnServerAboutToReconnect");

	UVehicleUserComponent_OnServerAboutToReconnect_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnRep_VehicleUserReconnRepData
// (Final, Native, Protected)

void UVehicleUserComponent::OnRep_VehicleUserReconnRepData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnRep_VehicleUserReconnRepData");

	UVehicleUserComponent_OnRep_VehicleUserReconnRepData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnInputAxisMoveRight
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::OnInputAxisMoveRight(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnInputAxisMoveRight");

	UVehicleUserComponent_OnInputAxisMoveRight_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnInputAxisMoveForward
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::OnInputAxisMoveForward(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnInputAxisMoveForward");

	UVehicleUserComponent_OnInputAxisMoveForward_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnExitVehicleCompleted
// (Event, Protected, BlueprintEvent)

void UVehicleUserComponent::OnExitVehicleCompleted()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnExitVehicleCompleted");

	UVehicleUserComponent_OnExitVehicleCompleted_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnEnterVehicleCompleted
// (Event, Protected, BlueprintEvent)
// Parameters:
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::OnEnterVehicleCompleted(ESTExtraVehicleSeatType SeatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnEnterVehicleCompleted");

	UVehicleUserComponent_OnEnterVehicleCompleted_Params params;
	params.SeatType = SeatType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnCurrrentClosestVehicleChanged
// (Event, Protected, BlueprintEvent)

void UVehicleUserComponent::OnCurrrentClosestVehicleChanged()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnCurrrentClosestVehicleChanged");

	UVehicleUserComponent_OnCurrrentClosestVehicleChanged_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.OnChangeVehicleSeatCompleted
// (Event, Protected, BlueprintEvent)
// Parameters:
// ESTExtraVehicleSeatType        SeatType                       (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::OnChangeVehicleSeatCompleted(ESTExtraVehicleSeatType SeatType)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.OnChangeVehicleSeatCompleted");

	UVehicleUserComponent_OnChangeVehicleSeatCompleted_Params params;
	params.SeatType = SeatType;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.NotifyLeaveVehicleFailed
// (Net, NetReliable, Native, Event, Public, NetClient)

void UVehicleUserComponent::NotifyLeaveVehicleFailed()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.NotifyLeaveVehicleFailed");

	UVehicleUserComponent_NotifyLeaveVehicleFailed_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.MoveVehicleRight
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::MoveVehicleRight(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.MoveVehicleRight");

	UVehicleUserComponent_MoveVehicleRight_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.MoveVehicleForward
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Rate                           (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::MoveVehicleForward(float Rate)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.MoveVehicleForward");

	UVehicleUserComponent_MoveVehicleForward_Params params;
	params.Rate = Rate;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VehicleUserComponent.GetVehicleUserState
// (Final, Native, Public, Const)
// Parameters:
// ESTExtraVehicleUserState       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

ESTExtraVehicleUserState UVehicleUserComponent::GetVehicleUserState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.GetVehicleUserState");

	UVehicleUserComponent_GetVehicleUserState_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleUserComponent.CanVehicleShoot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class ASTExtraPlayerCharacter* PlayerCharacter                (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleUserComponent::CanVehicleShoot(class ASTExtraPlayerCharacter* PlayerCharacter)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.CanVehicleShoot");

	UVehicleUserComponent_CanVehicleShoot_Params params;
	params.PlayerCharacter = PlayerCharacter;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleUserComponent.CanUseVehicleHorn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UVehicleUserComponent::CanUseVehicleHorn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.CanUseVehicleHorn");

	UVehicleUserComponent_CanUseVehicleHorn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VehicleUserComponent.AddVehicleFuel
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          Amount                         (Parm, ZeroConstructor, IsPlainOldData)

void UVehicleUserComponent::AddVehicleFuel(float Amount)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VehicleUserComponent.AddVehicleFuel");

	UVehicleUserComponent_AddVehicleFuel_Params params;
	params.Amount = Amount;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNInfectableArea.OnBeginOverlap
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AVNInfectableArea::OnBeginOverlap(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNInfectableArea.OnBeginOverlap");

	AVNInfectableArea_OnBeginOverlap_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNInstigatorInterface.GetVNInstigator
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* UVNInstigatorInterface::GetVNInstigator()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNInstigatorInterface.GetVNInstigator");

	UVNInstigatorInterface_GetVNInstigator_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VNPainCausingVolComponent.OnDamagePulse
// (Event, Public, BlueprintEvent)
// Parameters:
// float                          Damage                         (Parm, ZeroConstructor, IsPlainOldData)

void UVNPainCausingVolComponent::OnDamagePulse(float Damage)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNPainCausingVolComponent.OnDamagePulse");

	UVNPainCausingVolComponent_OnDamagePulse_Params params;
	params.Damage = Damage;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNPainCausingVolComponent.OnBeginOverlap
// (Final, Native, Private, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UVNPainCausingVolComponent::OnBeginOverlap(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNPainCausingVolComponent.OnBeginOverlap");

	UVNPainCausingVolComponent_OnBeginOverlap_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNPainCausingVolComponent.GetVNInstigator
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* UVNPainCausingVolComponent::GetVNInstigator()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNPainCausingVolComponent.GetVNInstigator");

	UVNPainCausingVolComponent_GetVNInstigator_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VNTargetedProjectileActor.TerminateManually
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AVNTargetedProjectileActor::TerminateManually()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNTargetedProjectileActor.TerminateManually");

	AVNTargetedProjectileActor_TerminateManually_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNTargetedProjectileActor.InitActor
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// struct FVector                 TgtActorLoc                    (Parm, IsPlainOldData)
// class AActor*                  _OwnwePawn                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 InitLocation                   (Parm, IsPlainOldData)

void AVNTargetedProjectileActor::InitActor(const struct FVector& TgtActorLoc, class AActor* _OwnwePawn, const struct FVector& InitLocation)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNTargetedProjectileActor.InitActor");

	AVNTargetedProjectileActor_InitActor_Params params;
	params.TgtActorLoc = TgtActorLoc;
	params._OwnwePawn = _OwnwePawn;
	params.InitLocation = InitLocation;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNTargetedProjectileActor.CalcSplineVelocity
// (Final, Native, Public, HasDefaults)
// Parameters:
// struct FVector                 ReturnValue                    (Parm, OutParm, ReturnParm, IsPlainOldData)

struct FVector AVNTargetedProjectileActor::CalcSplineVelocity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNTargetedProjectileActor.CalcSplineVelocity");

	AVNTargetedProjectileActor_CalcSplineVelocity_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.VNToxicGrenade.SetOwnerPawn
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class AActor*                  _ownerPawn                     (Parm, ZeroConstructor, IsPlainOldData)

void AVNToxicGrenade::SetOwnerPawn(class AActor* _ownerPawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.SetOwnerPawn");

	AVNToxicGrenade_SetOwnerPawn_Params params;
	params._ownerPawn = _ownerPawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNToxicGrenade.ServerStopAndDestroy
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)

void AVNToxicGrenade::ServerStopAndDestroy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.ServerStopAndDestroy");

	AVNToxicGrenade_ServerStopAndDestroy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNToxicGrenade.OnHitCallback
// (Final, Native, Public, HasOutParms, HasDefaults)
// Parameters:
// class UPrimitiveComponent*     HitComp                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// struct FVector                 NormalImpulse                  (Parm, IsPlainOldData)
// struct FHitResult              Hit                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AVNToxicGrenade::OnHitCallback(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.OnHitCallback");

	AVNToxicGrenade_OnHitCallback_Params params;
	params.HitComp = HitComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.NormalImpulse = NormalImpulse;
	params.Hit = Hit;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNToxicGrenade.OnBeginOverlap
// (Final, Native, Public, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     activatedComp                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void AVNToxicGrenade::OnBeginOverlap(class UPrimitiveComponent* activatedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.OnBeginOverlap");

	AVNToxicGrenade_OnBeginOverlap_Params params;
	params.activatedComp = activatedComp;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNToxicGrenade.OnActorOverlapped
// (Final, Native, Public)
// Parameters:
// class AActor*                  OverlappedActor                (Parm, ZeroConstructor, IsPlainOldData)
// class AActor*                  Other                          (Parm, ZeroConstructor, IsPlainOldData)

void AVNToxicGrenade::OnActorOverlapped(class AActor* OverlappedActor, class AActor* Other)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.OnActorOverlapped");

	AVNToxicGrenade_OnActorOverlapped_Params params;
	params.OverlappedActor = OverlappedActor;
	params.Other = Other;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VNToxicGrenade.Kill
// (Final, Native, Public)

void AVNToxicGrenade::Kill()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VNToxicGrenade.Kill");

	AVNToxicGrenade_Kill_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VoiceCheckObject.VoiceTick
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UVoiceCheckObject::VoiceTick(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VoiceCheckObject.VoiceTick");

	UVoiceCheckObject_VoiceTick_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VoiceCheckObject.AddWeaponShotVoice
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraShootWeapon*     Weapon                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isslience                      (Parm, ZeroConstructor, IsPlainOldData)

void UVoiceCheckObject::AddWeaponShotVoice(class ASTExtraShootWeapon* Weapon, const struct FVector& posVector, float showTime, bool isslience)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VoiceCheckObject.AddWeaponShotVoice");

	UVoiceCheckObject_AddWeaponShotVoice_Params params;
	params.Weapon = Weapon;
	params.posVector = posVector;
	params.showTime = showTime;
	params.isslience = isslience;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VoiceCheckObject.AddVehicleVoice
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraVehicleBase*     Vehicle                        (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void UVoiceCheckObject::AddVehicleVoice(class ASTExtraVehicleBase* Vehicle, const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VoiceCheckObject.AddVehicleVoice");

	UVoiceCheckObject_AddVehicleVoice_Params params;
	params.Vehicle = Vehicle;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VoiceCheckObject.AddGlassVoice
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void UVoiceCheckObject::AddGlassVoice(const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VoiceCheckObject.AddGlassVoice");

	UVoiceCheckObject_AddGlassVoice_Params params;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.VoiceCheckObject.AddCharacterMoveVoice
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ASTExtraBaseCharacter*   Character                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FVector                 posVector                      (Parm, IsPlainOldData)
// float                          showTime                       (Parm, ZeroConstructor, IsPlainOldData)

void UVoiceCheckObject::AddCharacterMoveVoice(class ASTExtraBaseCharacter* Character, const struct FVector& posVector, float showTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.VoiceCheckObject.AddCharacterMoveVoice");

	UVoiceCheckObject_AddCharacterMoveVoice_Params params;
	params.Character = Character;
	params.posVector = posVector;
	params.showTime = showTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode.SetRespawnTime
// (Final, Native, Public)
// Parameters:
// float                          InRespawnTime                  (Parm, ZeroConstructor, IsPlainOldData)

void AWarGameMode::SetRespawnTime(float InRespawnTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode.SetRespawnTime");

	AWarGameMode_SetRespawnTime_Params params;
	params.InRespawnTime = InRespawnTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode_GrandTheft.UpdateCharacterAttrModifier
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void AWarGameMode_GrandTheft::UpdateCharacterAttrModifier(class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_GrandTheft.UpdateCharacterAttrModifier");

	AWarGameMode_GrandTheft_UpdateCharacterAttrModifier_Params params;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode_GrandTheft.HandlePlayerPickupItem
// (Final, Native, Public)
// Parameters:
// int                            ItemID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            Count                          (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* PC                             (Parm, ZeroConstructor, IsPlainOldData)

void AWarGameMode_GrandTheft::HandlePlayerPickupItem(int ItemID, int Count, class ASTExtraPlayerController* PC)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_GrandTheft.HandlePlayerPickupItem");

	AWarGameMode_GrandTheft_HandlePlayerPickupItem_Params params;
	params.ItemID = ItemID;
	params.Count = Count;
	params.PC = PC;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode_GrandTheft.GetLastDamageCauser
// (Final, Native, Public)
// Parameters:
// uint32_t                       LastDamageCauserPlayerKey      (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* AWarGameMode_GrandTheft::GetLastDamageCauser(uint32_t LastDamageCauserPlayerKey)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_GrandTheft.GetLastDamageCauser");

	AWarGameMode_GrandTheft_GetLastDamageCauser_Params params;
	params.LastDamageCauserPlayerKey = LastDamageCauserPlayerKey;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameMode_GrandTheft.GetItemScore
// (Final, Native, Public)
// Parameters:
// int                            ItemSpecificID                 (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarGameMode_GrandTheft::GetItemScore(int ItemSpecificID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_GrandTheft.GetItemScore");

	AWarGameMode_GrandTheft_GetItemScore_Params params;
	params.ItemSpecificID = ItemSpecificID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameMode_TRW.SpawnResourcePoints
// (Final, Native, Public)

void AWarGameMode_TRW::SpawnResourcePoints()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_TRW.SpawnResourcePoints");

	AWarGameMode_TRW_SpawnResourcePoints_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode_TRW.HandleOccupyingSuccessed
// (Final, Native, Public)
// Parameters:
// TArray<class ASTExtraBaseCharacter*> OccupyingPlayers               (Parm, ZeroConstructor)

void AWarGameMode_TRW::HandleOccupyingSuccessed(TArray<class ASTExtraBaseCharacter*> OccupyingPlayers)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_TRW.HandleOccupyingSuccessed");

	AWarGameMode_TRW_HandleOccupyingSuccessed_Params params;
	params.OccupyingPlayers = OccupyingPlayers;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameMode_TRW.HandleAddBaseOccupyScoreEvent
// (Final, Native, Public)
// Parameters:
// int                            ScoreValue                     (Parm, ZeroConstructor, IsPlainOldData)
// int                            CampID                         (Parm, ZeroConstructor, IsPlainOldData)

void AWarGameMode_TRW::HandleAddBaseOccupyScoreEvent(int ScoreValue, int CampID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameMode_TRW.HandleAddBaseOccupyScoreEvent");

	AWarGameMode_TRW_HandleAddBaseOccupyScoreEvent_Params params;
	params.ScoreValue = ScoreValue;
	params.CampID = CampID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.UpdateRespawnCountDownUI
// (Native, Protected)

void AWarGameState::UpdateRespawnCountDownUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.UpdateRespawnCountDownUI");

	AWarGameState_UpdateRespawnCountDownUI_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.SetLastRespawnTimeUpdateTimeSecond
// (Final, Native, Public)

void AWarGameState::SetLastRespawnTimeUpdateTimeSecond()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.SetLastRespawnTimeUpdateTimeSecond");

	AWarGameState_SetLastRespawnTimeUpdateTimeSecond_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.OnRep_WinScore
// (Final, Native, Protected)

void AWarGameState::OnRep_WinScore()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.OnRep_WinScore");

	AWarGameState_OnRep_WinScore_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.OnRep_TeamCount
// (Final, Native, Protected)

void AWarGameState::OnRep_TeamCount()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.OnRep_TeamCount");

	AWarGameState_OnRep_TeamCount_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.OnRep_RespawnLeftTime
// (Final, Native, Protected)

void AWarGameState::OnRep_RespawnLeftTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.OnRep_RespawnLeftTime");

	AWarGameState_OnRep_RespawnLeftTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.OnRep_MatchLeftTime
// (Native, Protected)

void AWarGameState::OnRep_MatchLeftTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.OnRep_MatchLeftTime");

	AWarGameState_OnRep_MatchLeftTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.OnRep_LastRespawnTimeUpdateTimeSecond
// (Final, Native, Protected)

void AWarGameState::OnRep_LastRespawnTimeUpdateTimeSecond()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.OnRep_LastRespawnTimeUpdateTimeSecond");

	AWarGameState_OnRep_LastRespawnTimeUpdateTimeSecond_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState.GetWinScore
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarGameState::GetWinScore()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.GetWinScore");

	AWarGameState_GetWinScore_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState.GetTeamCount
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarGameState::GetTeamCount()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.GetTeamCount");

	AWarGameState_GetTeamCount_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState.GetRespawnLeftTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AWarGameState::GetRespawnLeftTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.GetRespawnLeftTime");

	AWarGameState_GetRespawnLeftTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState.GetMatchLeftTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                          ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

float AWarGameState::GetMatchLeftTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState.GetMatchLeftTime");

	AWarGameState_GetMatchLeftTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState_GrandTheft.UpdateTeamScore
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerState*     InstigatorPlayerState          (Parm, ZeroConstructor, IsPlainOldData)
// int                            ChangedScore                   (Parm, ZeroConstructor, IsPlainOldData)
// EWarScoreChangeReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarGameState_GrandTheft::UpdateTeamScore(class ASTExtraPlayerState* InstigatorPlayerState, int ChangedScore, EWarScoreChangeReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_GrandTheft.UpdateTeamScore");

	AWarGameState_GrandTheft_UpdateTeamScore_Params params;
	params.InstigatorPlayerState = InstigatorPlayerState;
	params.ChangedScore = ChangedScore;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState_GrandTheft.UpdateGlobalRepParam
// (Final, Native, Public)

void AWarGameState_GrandTheft::UpdateGlobalRepParam()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_GrandTheft.UpdateGlobalRepParam");

	AWarGameState_GrandTheft_UpdateGlobalRepParam_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState_GrandTheft.NotifyTeamScoreChanged
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerState*     InstigatorPlayerState          (Parm, ZeroConstructor, IsPlainOldData)
// EWarScoreChangeReason          Reason                         (Parm, ZeroConstructor, IsPlainOldData)

void AWarGameState_GrandTheft::NotifyTeamScoreChanged(class ASTExtraPlayerState* InstigatorPlayerState, EWarScoreChangeReason Reason)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_GrandTheft.NotifyTeamScoreChanged");

	AWarGameState_GrandTheft_NotifyTeamScoreChanged_Params params;
	params.InstigatorPlayerState = InstigatorPlayerState;
	params.Reason = Reason;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState_GrandTheft.LoseScore
// (Final, Native, Public)
// Parameters:
// class ASTExtraPlayerState*     TargetPlayerState              (Parm, ZeroConstructor, IsPlainOldData)
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarGameState_GrandTheft::LoseScore(class ASTExtraPlayerState* TargetPlayerState)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_GrandTheft.LoseScore");

	AWarGameState_GrandTheft_LoseScore_Params params;
	params.TargetPlayerState = TargetPlayerState;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState_GrandTheft.FindScoreLeader
// (Final, Native, Public)
// Parameters:
// class AWarPlayerState*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AWarPlayerState* AWarGameState_GrandTheft::FindScoreLeader()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_GrandTheft.FindScoreLeader");

	AWarGameState_GrandTheft_FindScoreLeader_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarGameState_TRW.OnRep_ResActorArray
// (Final, Native, Protected)

void AWarGameState_TRW::OnRep_ResActorArray()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_TRW.OnRep_ResActorArray");

	AWarGameState_TRW_OnRep_ResActorArray_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState_TRW.OnRep_MatchLeftTime
// (Native, Protected)

void AWarGameState_TRW::OnRep_MatchLeftTime()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_TRW.OnRep_MatchLeftTime");

	AWarGameState_TRW_OnRep_MatchLeftTime_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarGameState_TRW.OnRep_CampScoreList
// (Final, Native, Public)

void AWarGameState_TRW::OnRep_CampScoreList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarGameState_TRW.OnRep_CampScoreList");

	AWarGameState_TRW_OnRep_CampScoreList_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarPlayerState.OnRep_PlayerStateScore
// (Final, Native, Protected)

void AWarPlayerState::OnRep_PlayerStateScore()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarPlayerState.OnRep_PlayerStateScore");

	AWarPlayerState_OnRep_PlayerStateScore_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarPlayerState_GrandTheft.OnRep_ThiefLocation
// (Final, Native, Public)

void AWarPlayerState_GrandTheft::OnRep_ThiefLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarPlayerState_GrandTheft.OnRep_ThiefLocation");

	AWarPlayerState_GrandTheft_OnRep_ThiefLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarPlayerState_GrandTheft.OnRep_ScoreLeaderLocation
// (Final, Native, Public)

void AWarPlayerState_GrandTheft::OnRep_ScoreLeaderLocation()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarPlayerState_GrandTheft.OnRep_ScoreLeaderLocation");

	AWarPlayerState_GrandTheft_OnRep_ScoreLeaderLocation_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarPlayerState_GrandTheft.LoseScore
// (Final, Native, Public)
// Parameters:
// int                            ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

int AWarPlayerState_GrandTheft::LoseScore()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarPlayerState_GrandTheft.LoseScore");

	AWarPlayerState_GrandTheft_LoseScore_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WarPlayerState_GrandTheft.AddScore
// (Final, Native, Public)
// Parameters:
// int                            NewScore                       (Parm, ZeroConstructor, IsPlainOldData)

void AWarPlayerState_GrandTheft::AddScore(int NewScore)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarPlayerState_GrandTheft.AddScore");

	AWarPlayerState_GrandTheft_AddScore_Params params;
	params.NewScore = NewScore;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarResWidget.SetTRWResActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AExtraTeamRWResActor*    RA                             (Parm, ZeroConstructor, IsPlainOldData)

void UWarResWidget::SetTRWResActor(class AExtraTeamRWResActor* RA)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarResWidget.SetTRWResActor");

	UWarResWidget_SetTRWResActor_Params params;
	params.RA = RA;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WarResWidget.BindResActorEvent
// (Event, Public, BlueprintEvent)

void UWarResWidget::BindResActorEvent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WarResWidget.BindResActorEvent");

	UWarResWidget_BindResActorEvent_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponStopFire
// (Final, Native, Protected)

void UWeaponAntiCheatComp::OnWeaponStopFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponStopFire");

	UWeaponAntiCheatComp_OnWeaponStopFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponStartFire
// (Final, Native, Protected)

void UWeaponAntiCheatComp::OnWeaponStartFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponStartFire");

	UWeaponAntiCheatComp_OnWeaponStartFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponShootHit
// (Final, Native, Protected, HasOutParms)
// Parameters:
// struct FShootWeaponDamageEvent DamageDetail                   (ConstParm, Parm, OutParm, ReferenceParm)
// struct FBulletHitInfoUploadData HitData                        (ConstParm, Parm, OutParm, ReferenceParm)
// struct FLocalShootHitData      LocalHitData                   (ConstParm, Parm, OutParm, ReferenceParm)

void UWeaponAntiCheatComp::OnWeaponShootHit(const struct FShootWeaponDamageEvent& DamageDetail, const struct FBulletHitInfoUploadData& HitData, const struct FLocalShootHitData& LocalHitData)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponShootHit");

	UWeaponAntiCheatComp_OnWeaponShootHit_Params params;
	params.DamageDetail = DamageDetail;
	params.HitData = HitData;
	params.LocalHitData = LocalHitData;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponReloaded
// (Final, Native, Protected)

void UWeaponAntiCheatComp::OnWeaponReloaded()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAntiCheatComp.OnWeaponReloaded");

	UWeaponAntiCheatComp_OnWeaponReloaded_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.TryDoAiming
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAutoAimingComponent::TryDoAiming(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.TryDoAiming");

	UWeaponAutoAimingComponent_TryDoAiming_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.SetCD
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          CDTime                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAutoAimingComponent::SetCD(float CDTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.SetCD");

	UWeaponAutoAimingComponent_SetCD_Params params;
	params.CDTime = CDTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.SelectAimTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                          DeltaTime                      (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAutoAimingComponent::SelectAimTarget(float DeltaTime)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.SelectAimTarget");

	UWeaponAutoAimingComponent_SelectAimTarget_Params params;
	params.DeltaTime = DeltaTime;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnUnEquipWeapon
// (Final, Native, Public, BlueprintCallable)

void UWeaponAutoAimingComponent::OnUnEquipWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnUnEquipWeapon");

	UWeaponAutoAimingComponent_OnUnEquipWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnShoot
// (Final, Native, Private)
// Parameters:
// class ASTExtraWeapon*          Weapon                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAutoAimingComponent::OnShoot(class ASTExtraWeapon* Weapon)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnShoot");

	UWeaponAutoAimingComponent_OnShoot_Params params;
	params.Weapon = Weapon;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnEquipWeapon
// (Final, Native, Public, BlueprintCallable)

void UWeaponAutoAimingComponent::OnEquipWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.OnEquipWeapon");

	UWeaponAutoAimingComponent_OnEquipWeapon_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.IsTeammate
// (Final, Native, Private)
// Parameters:
// class ASTExtraPlayerState*     PlayerState                    (Parm, ZeroConstructor, IsPlainOldData)
// class ASTExtraPlayerCharacter* Character                      (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::IsTeammate(class ASTExtraPlayerState* PlayerState, class ASTExtraPlayerCharacter* Character)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.IsTeammate");

	UWeaponAutoAimingComponent_IsTeammate_Params params;
	params.PlayerState = PlayerState;
	params.Character = Character;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.isOpenFire
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::isOpenFire()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.isOpenFire");

	UWeaponAutoAimingComponent_isOpenFire_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.IsCool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::IsCool()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.IsCool");

	UWeaponAutoAimingComponent_IsCool_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.Init
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AController*             Controller                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAutoAimingComponent::Init(class AController* Controller)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.Init");

	UWeaponAutoAimingComponent_Init_Params params;
	params.Controller = Controller;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.FindInRangeEnemies
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<struct FAutoAimEnemyInfo> InRangeEnemyList               (Parm, OutParm, ZeroConstructor)

void UWeaponAutoAimingComponent::FindInRangeEnemies(TArray<struct FAutoAimEnemyInfo>* InRangeEnemyList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.FindInRangeEnemies");

	UWeaponAutoAimingComponent_FindInRangeEnemies_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (InRangeEnemyList != nullptr)
		*InRangeEnemyList = params.InRangeEnemyList;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.FindBarrierFreeEnemy
// (Final, Native, Private, HasOutParms)
// Parameters:
// TArray<struct FAutoAimEnemyInfo> InRangeEnemyList               (Parm, OutParm, ZeroConstructor)

void UWeaponAutoAimingComponent::FindBarrierFreeEnemy(TArray<struct FAutoAimEnemyInfo>* InRangeEnemyList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.FindBarrierFreeEnemy");

	UWeaponAutoAimingComponent_FindBarrierFreeEnemy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (InRangeEnemyList != nullptr)
		*InRangeEnemyList = params.InRangeEnemyList;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.ClearCD
// (Final, Native, Public, BlueprintCallable)

void UWeaponAutoAimingComponent::ClearCD()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.ClearCD");

	UWeaponAutoAimingComponent_ClearCD_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.CheckSmoke
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                 startPoint                     (Parm, IsPlainOldData)
// class ASTExtraPlayerCharacter* Pawn                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::CheckSmoke(const struct FVector& startPoint, class ASTExtraPlayerCharacter* Pawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.CheckSmoke");

	UWeaponAutoAimingComponent_CheckSmoke_Params params;
	params.startPoint = startPoint;
	params.Pawn = Pawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.CheckBuffStun
// (Final, Native, Public)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::CheckBuffStun()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.CheckBuffStun");

	UWeaponAutoAimingComponent_CheckBuffStun_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAutoAimingComponent.CanEnemeyRaycastReach
// (Native, Event, Public, HasDefaults, BlueprintEvent)
// Parameters:
// struct FVector                 startPoint                     (Parm, IsPlainOldData)
// class ASTExtraPlayerCharacter* Pawn                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAutoAimingComponent::CanEnemeyRaycastReach(const struct FVector& startPoint, class ASTExtraPlayerCharacter* Pawn)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAutoAimingComponent.CanEnemeyRaycastReach");

	UWeaponAutoAimingComponent_CanEnemeyRaycastReach_Params params;
	params.startPoint = startPoint;
	params.Pawn = Pawn;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ResetAttachmentParent
// (Final, Native, Public, BlueprintCallable)

void UWeaponAvatarComponent::ResetAttachmentParent()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ResetAttachmentParent");

	UWeaponAvatarComponent_ResetAttachmentParent_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.RemoveParticleEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::RemoveParticleEffect(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.RemoveParticleEffect");

	UWeaponAvatarComponent_RemoveParticleEffect_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ReloadItemHandle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBattleItemHandleBase* UWeaponAvatarComponent::ReloadItemHandle(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ReloadItemHandle");

	UWeaponAvatarComponent_ReloadItemHandle_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnMasterComponentByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackWeaponHandle*   weaponHandle                   (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           skMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             stMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::PutOnMasterComponentByItemHandle(class UBackpackWeaponHandle* weaponHandle, class USkeletalMesh* skMesh, class UStaticMesh* stMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnMasterComponentByItemHandle");

	UWeaponAvatarComponent_PutOnMasterComponentByItemHandle_Params params;
	params.weaponHandle = weaponHandle;
	params.skMesh = skMesh;
	params.stMesh = stMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnEquipmentByResID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::PutOnEquipmentByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnEquipmentByResID");

	UWeaponAvatarComponent_PutOnEquipmentByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnEquipmentByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           skMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             stMesh                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::PutOnEquipmentByItemHandle(class UBattleItemHandleBase* ItemHandle, class USkeletalMesh* skMesh, class UStaticMesh* stMesh)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.PutOnEquipmentByItemHandle");

	UWeaponAvatarComponent_PutOnEquipmentByItemHandle_Params params;
	params.ItemHandle = ItemHandle;
	params.skMesh = skMesh;
	params.stMesh = stMesh;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.PutOffEquimentByResID
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int                            resID                          (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::PutOffEquimentByResID(int resID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.PutOffEquimentByResID");

	UWeaponAvatarComponent_PutOffEquimentByResID_Params params;
	params.resID = resID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// DelegateFunction ShadowTrackerExtra.WeaponAvatarComponent.OnScopeUnequipDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponAvatarComponent::OnScopeUnequipDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponAvatarComponent.OnScopeUnequipDelegate__DelegateSignature");

	UWeaponAvatarComponent_OnScopeUnequipDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponAvatarComponent.OnScopeEquipDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponAvatarComponent::OnScopeEquipDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponAvatarComponent.OnScopeEquipDelegate__DelegateSignature");

	UWeaponAvatarComponent_OnScopeEquipDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.OnMeshLoaded
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FSoftObjectPath         AssetList                      (Parm)
// class UBattleItemHandleBase*   itemHandles                    (Parm, ZeroConstructor, IsPlainOldData)
// bool                           isReplaced                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::OnMeshLoaded(const struct FSoftObjectPath& AssetList, class UBattleItemHandleBase* itemHandles, bool isReplaced)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.OnMeshLoaded");

	UWeaponAvatarComponent_OnMeshLoaded_Params params;
	params.AssetList = AssetList;
	params.itemHandles = itemHandles;
	params.isReplaced = isReplaced;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.OnItemHandleLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::OnItemHandleLoaded(const struct FItemDefineID& DefineID, class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.OnItemHandleLoaded");

	UWeaponAvatarComponent_OnItemHandleLoaded_Params params;
	params.DefineID = DefineID;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.OnDefaultItemLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::OnDefaultItemLoaded(const struct FItemDefineID& DefineID, class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.OnDefaultItemLoaded");

	UWeaponAvatarComponent_OnDefaultItemLoaded_Params params;
	params.DefineID = DefineID;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.OnAttachItemLoaded
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::OnAttachItemLoaded(const struct FItemDefineID& DefineID, class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.OnAttachItemLoaded");

	UWeaponAvatarComponent_OnAttachItemLoaded_Params params;
	params.DefineID = DefineID;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.NetSyncData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// ESyncOperation                 Type                           (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::NetSyncData(int Slot, ESyncOperation Type, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.NetSyncData");

	UWeaponAvatarComponent_NetSyncData_Params params;
	params.Slot = Slot;
	params.Type = Type;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.LoadMeshsAsync
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   handleList                     (Parm, ZeroConstructor, IsPlainOldData)
// bool                           needDirectLoad                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::LoadMeshsAsync(class UBattleItemHandleBase* handleList, bool needDirectLoad)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.LoadMeshsAsync");

	UWeaponAvatarComponent_LoadMeshsAsync_Params params;
	params.handleList = handleList;
	params.needDirectLoad = needDirectLoad;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.LoadDefaultAttachmentsAsync
// (Final, Native, Public, BlueprintCallable)

void UWeaponAvatarComponent::LoadDefaultAttachmentsAsync()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.LoadDefaultAttachmentsAsync");

	UWeaponAvatarComponent_LoadDefaultAttachmentsAsync_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.IsTeammate
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::IsTeammate()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.IsTeammate");

	UWeaponAvatarComponent_IsTeammate_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.IsAutonomousAvatar
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::IsAutonomousAvatar()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.IsAutonomousAvatar");

	UWeaponAvatarComponent_IsAutonomousAvatar_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.InitMasterComponent
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            AGender                        (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::InitMasterComponent(int AGender)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.InitMasterComponent");

	UWeaponAvatarComponent_InitMasterComponent_Params params;
	params.AGender = AGender;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.InitialAvatarParam
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            AGender                        (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::InitialAvatarParam(int AGender)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.InitialAvatarParam");

	UWeaponAvatarComponent_InitialAvatarParam_Params params;
	params.AGender = AGender;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultMesh
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::InitDefaultMesh(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultMesh");

	UWeaponAvatarComponent_InitDefaultMesh_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultAvatar
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::InitDefaultAvatar(class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultAvatar");

	UWeaponAvatarComponent_InitDefaultAvatar_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultAttachment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackWeaponHandle*   weaponHandle                   (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::InitDefaultAttachment(class UBackpackWeaponHandle* weaponHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.InitDefaultAttachment");

	UWeaponAvatarComponent_InitDefaultAttachment_Params params;
	params.weaponHandle = weaponHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetWeaponController
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* UWeaponAvatarComponent::GetWeaponController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetWeaponController");

	UWeaponAvatarComponent_GetWeaponController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetStaticMesh
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FWeaponMeshCfg          meshPack                       (ConstParm, Parm, OutParm, ReferenceParm)
// class UStaticMesh*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UStaticMesh* UWeaponAvatarComponent::GetStaticMesh(const struct FWeaponMeshCfg& meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetStaticMesh");

	UWeaponAvatarComponent_GetStaticMesh_Params params;
	params.meshPack = meshPack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetSocketName
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            subSlotID                      (Parm, ZeroConstructor, IsPlainOldData)
// struct FName                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

struct FName UWeaponAvatarComponent::GetSocketName(int slotID, int subSlotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetSocketName");

	UWeaponAvatarComponent_GetSocketName_Params params;
	params.slotID = slotID;
	params.subSlotID = subSlotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetSkeletalMesh
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FWeaponMeshCfg          meshPack                       (ConstParm, Parm, OutParm, ReferenceParm)
// class USkeletalMesh*           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class USkeletalMesh* UWeaponAvatarComponent::GetSkeletalMesh(const struct FWeaponMeshCfg& meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetSkeletalMesh");

	UWeaponAvatarComponent_GetSkeletalMesh_Params params;
	params.meshPack = meshPack;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetParticleSystem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackWeaponAttachHandle* WeaponAttachHandle             (Parm, ZeroConstructor, IsPlainOldData)
// int                            ParticleIdx                    (Parm, ZeroConstructor, IsPlainOldData)
// class UParticleSystem*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UParticleSystem* UWeaponAvatarComponent::GetParticleSystem(class UBackpackWeaponAttachHandle* WeaponAttachHandle, int ParticleIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetParticleSystem");

	UWeaponAvatarComponent_GetParticleSystem_Params params;
	params.WeaponAttachHandle = WeaponAttachHandle;
	params.ParticleIdx = ParticleIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshResRef
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FSoftObjectPath         AssetRef                       (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::GetMeshResRef(class UBattleItemHandleBase* Handle, struct FSoftObjectPath* AssetRef)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshResRef");

	UWeaponAvatarComponent_GetMeshResRef_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (AssetRef != nullptr)
		*AssetRef = params.AssetRef;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshPack
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// struct FWeaponMeshCfg          meshCfg                        (Parm, OutParm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::GetMeshPack(class UBattleItemHandleBase* Handle, struct FWeaponMeshCfg* meshCfg)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshPack");

	UWeaponAvatarComponent_GetMeshPack_Params params;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshCfg != nullptr)
		*meshCfg = params.meshCfg;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshComponentBySlotID
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* UWeaponAvatarComponent::GetMeshComponentBySlotID(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetMeshComponentBySlotID");

	UWeaponAvatarComponent_GetMeshComponentBySlotID_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetMaterial
// (Final, Native, Public, HasOutParms, BlueprintCallable)
// Parameters:
// struct FWeaponMeshCfg          meshPack                       (Parm, OutParm)
// class UMaterialInstance*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UMaterialInstance* UWeaponAvatarComponent::GetMaterial(struct FWeaponMeshCfg* meshPack)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetMaterial");

	UWeaponAvatarComponent_GetMaterial_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (meshPack != nullptr)
		*meshPack = params.meshPack;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetEquippedHandle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackWeaponAttachHandle* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UBackpackWeaponAttachHandle* UWeaponAvatarComponent::GetEquippedHandle(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetEquippedHandle");

	UWeaponAvatarComponent_GetEquippedHandle_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetAttachmentSocketTransform
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          ReturnValue                    (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)

class UMeshComponent* UWeaponAvatarComponent::GetAttachmentSocketTransform(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetAttachmentSocketTransform");

	UWeaponAvatarComponent_GetAttachmentSocketTransform_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.GetAttachmentAnim
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWeaponAttachmentSocketType    slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// int                            AnimIdx                        (Parm, ZeroConstructor, IsPlainOldData)
// class UAnimationAsset*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UAnimationAsset* UWeaponAvatarComponent::GetAttachmentAnim(EWeaponAttachmentSocketType slotID, int AnimIdx)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.GetAttachmentAnim");

	UWeaponAvatarComponent_GetAttachmentAnim_Params params;
	params.slotID = slotID;
	params.AnimIdx = AnimIdx;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ClearMeshBySlot
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// bool                           putDefault                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::ClearMeshBySlot(int Slot, bool putDefault)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ClearMeshBySlot");

	UWeaponAvatarComponent_ClearMeshBySlot_Params params;
	params.Slot = Slot;
	params.putDefault = putDefault;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ClearMeshByItemHandle
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::ClearMeshByItemHandle(class UBattleItemHandleBase* ItemHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ClearMeshByItemHandle");

	UWeaponAvatarComponent_ClearMeshByItemHandle_Params params;
	params.ItemHandle = ItemHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.CheckSlotIsEquipped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            slotID                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::CheckSlotIsEquipped(int slotID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.CheckSlotIsEquipped");

	UWeaponAvatarComponent_CheckSlotIsEquipped_Params params;
	params.slotID = slotID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.CheckIsAlreadyEquipped
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FItemDefineID           DefineID                       (Parm)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::CheckIsAlreadyEquipped(const struct FItemDefineID& DefineID)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.CheckIsAlreadyEquipped");

	UWeaponAvatarComponent_CheckIsAlreadyEquipped_Params params;
	params.DefineID = DefineID;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyStaticMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UStaticMesh*             pSM                            (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::ApplyStaticMeshByID(int Slot, class UStaticMesh* pSM, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyStaticMeshByID");

	UWeaponAvatarComponent_ApplyStaticMeshByID_Params params;
	params.Slot = Slot;
	params.pSM = pSM;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplySkeletalMeshByID
// (Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class USkeletalMesh*           Mesh                           (Parm, ZeroConstructor, IsPlainOldData)
// class UMaterialInstance*       Mat                            (Parm, ZeroConstructor, IsPlainOldData)
// class UBattleItemHandleBase*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)
// bool                           ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

bool UWeaponAvatarComponent::ApplySkeletalMeshByID(int Slot, class USkeletalMesh* Mesh, class UMaterialInstance* Mat, class UBattleItemHandleBase* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplySkeletalMeshByID");

	UWeaponAvatarComponent_ApplySkeletalMeshByID_Params params;
	params.Slot = Slot;
	params.Mesh = Mesh;
	params.Mat = Mat;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyParticleEffect
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackWeaponAttachHandle* Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::ApplyParticleEffect(int Slot, class UBackpackWeaponAttachHandle* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyParticleEffect");

	UWeaponAvatarComponent_ApplyParticleEffect_Params params;
	params.Slot = Slot;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyMaterial
// (Native, Public, BlueprintCallable)
// Parameters:
// class UBattleItemHandleBase*   ItemHandle                     (Parm, ZeroConstructor, IsPlainOldData)
// class UMeshComponent*          meshComp                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)

void UWeaponAvatarComponent::ApplyMaterial(class UBattleItemHandleBase* ItemHandle, class UMeshComponent* meshComp)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyMaterial");

	UWeaponAvatarComponent_ApplyMaterial_Params params;
	params.ItemHandle = ItemHandle;
	params.meshComp = meshComp;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyAttachment
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBackpackWeaponAttachHandle* attachHandle                   (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::ApplyAttachment(class UBackpackWeaponAttachHandle* attachHandle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyAttachment");

	UWeaponAvatarComponent_ApplyAttachment_Params params;
	params.attachHandle = attachHandle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int                            Slot                           (Parm, ZeroConstructor, IsPlainOldData)
// class UBackpackWeaponHandle*   Handle                         (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponAvatarComponent::ApplyAnimation(int Slot, class UBackpackWeaponHandle* Handle)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponAvatarComponent.ApplyAnimation");

	UWeaponAvatarComponent_ApplyAnimation_Params params;
	params.Slot = Slot;
	params.Handle = Handle;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// DelegateFunction ShadowTrackerExtra.WeaponOwnerProxy.OnWeaponStopFireDelegate__DelegateSignature
// (MulticastDelegate, Public, Delegate)

void UWeaponOwnerProxy::OnWeaponStopFireDelegate__DelegateSignature()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("DelegateFunction ShadowTrackerExtra.WeaponOwnerProxy.OnWeaponStopFireDelegate__DelegateSignature");

	UWeaponOwnerProxy_OnWeaponStopFireDelegate__DelegateSignature_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.HandlePlayerSwitchCameraMode
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EPlayerCameraMode> Mode                           (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponOwnerProxy::HandlePlayerSwitchCameraMode(TEnumAsByte<EPlayerCameraMode> Mode)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.HandlePlayerSwitchCameraMode");

	UWeaponOwnerProxy_HandlePlayerSwitchCameraMode_Params params;
	params.Mode = Mode;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.HandlePlayerChangePose
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<ESTEPoseState>     LastPose                       (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<ESTEPoseState>     NewPose                        (Parm, ZeroConstructor, IsPlainOldData)

void UWeaponOwnerProxy::HandlePlayerChangePose(TEnumAsByte<ESTEPoseState> LastPose, TEnumAsByte<ESTEPoseState> NewPose)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.HandlePlayerChangePose");

	UWeaponOwnerProxy_HandlePlayerChangePose_Params params;
	params.LastPose = LastPose;
	params.NewPose = NewPose;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerSTExtraPlayerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraPlayerController* ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraPlayerController* UWeaponOwnerProxy::GetOwnerSTExtraPlayerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerSTExtraPlayerController");

	UWeaponOwnerProxy_GetOwnerSTExtraPlayerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerSTExtraPlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ASTExtraBaseCharacter*   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class ASTExtraBaseCharacter* UWeaponOwnerProxy::GetOwnerSTExtraPlayerCharacter()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerSTExtraPlayerCharacter");

	UWeaponOwnerProxy_GetOwnerSTExtraPlayerCharacter_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerPlayerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APlayerController*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APlayerController* UWeaponOwnerProxy::GetOwnerPlayerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerPlayerController");

	UWeaponOwnerProxy_GetOwnerPlayerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerPawn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                   ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class APawn* UWeaponOwnerProxy::GetOwnerPawn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerPawn");

	UWeaponOwnerProxy_GetOwnerPawn_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AController*             ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AController* UWeaponOwnerProxy::GetOwnerController()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerController");

	UWeaponOwnerProxy_GetOwnerController_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                  ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class AActor* UWeaponOwnerProxy::GetOwnerActor()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxy.GetOwnerActor");

	UWeaponOwnerProxy_GetOwnerActor_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponOwnerProxyFactory.GetWeaponOwnerProxy
// (Native, Public)
// Parameters:
// class UWeaponOwnerProxy*       ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UWeaponOwnerProxy* UWeaponOwnerProxyFactory::GetWeaponOwnerProxy()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponOwnerProxyFactory.GetWeaponOwnerProxy");

	UWeaponOwnerProxyFactory_GetWeaponOwnerProxy_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WeaponSpecificHandler.GetBackpackItemHandle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UItemHandleBase*         ReturnValue                    (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)

class UItemHandleBase* UWeaponSpecificHandler::GetBackpackItemHandle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WeaponSpecificHandler.GetBackpackItemHandle");

	UWeaponSpecificHandler_GetBackpackItemHandle_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	return params.ReturnValue;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.StopRecord
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                           bRankFirst                     (Parm, ZeroConstructor, IsPlainOldData)

void UWonderfulRecordingCut::StopRecord(bool bRankFirst)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.StopRecord");

	UWonderfulRecordingCut_StopRecord_Params params;
	params.bRankFirst = bRankFirst;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.StartRecord
// (Final, Native, Public, BlueprintCallable)

void UWonderfulRecordingCut::StartRecord()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.StartRecord");

	UWonderfulRecordingCut_StartRecord_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.SortShootDamageData
// (Final, Native, Protected, HasOutParms)
// Parameters:
// TArray<struct FWonderfulCutShootDamageSortData> LargeCircleDataList            (Parm, OutParm, ZeroConstructor)
// TArray<struct FWonderfulCutShootDamageSortData> SmallCircleDataList            (Parm, OutParm, ZeroConstructor)

void UWonderfulRecordingCut::SortShootDamageData(TArray<struct FWonderfulCutShootDamageSortData>* LargeCircleDataList, TArray<struct FWonderfulCutShootDamageSortData>* SmallCircleDataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.SortShootDamageData");

	UWonderfulRecordingCut_SortShootDamageData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (LargeCircleDataList != nullptr)
		*LargeCircleDataList = params.LargeCircleDataList;
	if (SmallCircleDataList != nullptr)
		*SmallCircleDataList = params.SmallCircleDataList;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.RemoveOutputDataInContinuousKillRange
// (Final, Native, Protected, HasOutParms)
// Parameters:
// TArray<struct FWonderfulCutShootDamageSortData> SortDataList                   (Parm, OutParm, ZeroConstructor)

void UWonderfulRecordingCut::RemoveOutputDataInContinuousKillRange(TArray<struct FWonderfulCutShootDamageSortData>* SortDataList)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.RemoveOutputDataInContinuousKillRange");

	UWonderfulRecordingCut_RemoveOutputDataInContinuousKillRange_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;

	if (SortDataList != nullptr)
		*SortDataList = params.SortDataList;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.CaptureRecordCut
// (Final, Native, Public)
// Parameters:
// TEnumAsByte<EWonderfulCutCaptureType> CaptureType                    (Parm, ZeroConstructor, IsPlainOldData)
// int                            DamagePlayerID                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bAI                            (Parm, ZeroConstructor, IsPlainOldData)
// TEnumAsByte<EWonderfulCutShootDamageType> ShootDamageType                (Parm, ZeroConstructor, IsPlainOldData)
// float                          ShootDistance                  (Parm, ZeroConstructor, IsPlainOldData)
// struct FString                 causerName                     (Parm, ZeroConstructor)

void UWonderfulRecordingCut::CaptureRecordCut(TEnumAsByte<EWonderfulCutCaptureType> CaptureType, int DamagePlayerID, bool bAI, TEnumAsByte<EWonderfulCutShootDamageType> ShootDamageType, float ShootDistance, const struct FString& causerName)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.CaptureRecordCut");

	UWonderfulRecordingCut_CaptureRecordCut_Params params;
	params.CaptureType = CaptureType;
	params.DamagePlayerID = DamagePlayerID;
	params.bAI = bAI;
	params.ShootDamageType = ShootDamageType;
	params.ShootDistance = ShootDistance;
	params.causerName = causerName;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.BuildOutputData
// (Final, Native, Protected)

void UWonderfulRecordingCut::BuildOutputData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.BuildOutputData");

	UWonderfulRecordingCut_BuildOutputData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WonderfulRecordingCut.BuildContinuousKillOutputData
// (Final, Native, Protected)

void UWonderfulRecordingCut::BuildContinuousKillOutputData()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WonderfulRecordingCut.BuildContinuousKillOutputData");

	UWonderfulRecordingCut_BuildContinuousKillOutputData_Params params;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WrapperOverlapManagerComponent.HandleOnBeginOverlap
// (Final, Native, Protected, HasOutParms)
// Parameters:
// class UPrimitiveComponent*     OverlappedComponent            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)
// bool                           bFromSweep                     (Parm, ZeroConstructor, IsPlainOldData)
// struct FHitResult              SweepResult                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)

void UWrapperOverlapManagerComponent::HandleOnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WrapperOverlapManagerComponent.HandleOnBeginOverlap");

	UWrapperOverlapManagerComponent_HandleOnBeginOverlap_Params params;
	params.OverlappedComponent = OverlappedComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;
	params.bFromSweep = bFromSweep;
	params.SweepResult = SweepResult;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function ShadowTrackerExtra.WrapperOverlapManagerComponent.HandleEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*     OverlappedComponent            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// class AActor*                  OtherActor                     (Parm, ZeroConstructor, IsPlainOldData)
// class UPrimitiveComponent*     OtherComp                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
// int                            OtherBodyIndex                 (Parm, ZeroConstructor, IsPlainOldData)

void UWrapperOverlapManagerComponent::HandleEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int OtherBodyIndex)
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function ShadowTrackerExtra.WrapperOverlapManagerComponent.HandleEndOverlap");

	UWrapperOverlapManagerComponent_HandleEndOverlap_Params params;
	params.OverlappedComponent = OverlappedComponent;
	params.OtherActor = OtherActor;
	params.OtherComp = OtherComp;
	params.OtherBodyIndex = OtherBodyIndex;

	auto flags = pFunc->FunctionFlags;
	pFunc->FunctionFlags |= 0x400;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


}