pubg/SDK/PUBGM_Gameplay_parameters.hpp

#pragma once

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

#include "../SDK.hpp"

namespace SDK
{
//---------------------------------------------------------------------------
//Parameters
//---------------------------------------------------------------------------

// Function Gameplay.UAEGameMode.SyncPlayerNames
struct AUAEGameMode_SyncPlayerNames_Params
{
};

// Function Gameplay.UAEGameMode.SyncNewCorpsData
struct AUAEGameMode_SyncNewCorpsData_Params
{
	TArray<struct FDSCorpsInfo>                        OutCorpsData;                                             // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
};

// Function Gameplay.UAEGameMode.SpawnUAEPawnFor
struct AUAEGameMode_SpawnUAEPawnFor_Params
{
	class AController*                                 NewPlayer;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FTransform                                  Trans;                                                    // (Parm, IsPlainOldData)
	class APawn*                                       ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.SoftKickPlayer
struct AUAEGameMode_SoftKickPlayer_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bSendFailure;                                             // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     FailureMessage;                                           // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEGameMode.SetPlayerOpenId
struct AUAEGameMode_SetPlayerOpenId_Params
{
	uint32_t                                           InPlayerKey;                                              // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     InPlayerOpenID;                                           // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEGameMode.RetrieveTeamBattleResultData
struct AUAEGameMode_RetrieveTeamBattleResultData_Params
{
	int                                                TeamID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	struct FGameModeTeamBattleResultData               ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.UAEGameMode.RetrieveBattleData
struct AUAEGameMode_RetrieveBattleData_Params
{
	struct FBattleData                                 OutBattleData;                                            // (Parm, OutParm)
};

// Function Gameplay.UAEGameMode.RestartPlayerAtPlayerStart
struct AUAEGameMode_RestartPlayerAtPlayerStart_Params
{
	class AController*                                 NewPlayer;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	class AActor*                                      StartSpot;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.Rescue
struct AUAEGameMode_Rescue_Params
{
	class APawn*                                       RescueWho;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	class APawn*                                       Hero;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.RegisterItemGroupSpotsByTag
struct AUAEGameMode_RegisterItemGroupSpotsByTag_Params
{
	struct FName                                       Tag;                                                      // (Parm, ZeroConstructor, IsPlainOldData)
	class UGroupSpotSceneComponent*                    GroupSpotComponent;                                       // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.RegisterItemGroupSpots
struct AUAEGameMode_RegisterItemGroupSpots_Params
{
	class UGroupSpotSceneComponent*                    GroupSpotComponent;                                       // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.RefreshWorldActiveRange
struct AUAEGameMode_RefreshWorldActiveRange_Params
{
};

// Function Gameplay.UAEGameMode.RefreshWatchTeammates
struct AUAEGameMode_RefreshWatchTeammates_Params
{
	class AUAEPlayerController*                        InController;                                             // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                InTeamID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.RefreshPlayerNames
struct AUAEGameMode_RefreshPlayerNames_Params
{
	uint32_t                                           InPlayerKey;                                              // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     InPlayerName;                                             // (Parm, ZeroConstructor)
	int                                                TeamID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               IsLogin;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.RecoardAlivePlayerNum
struct AUAEGameMode_RecoardAlivePlayerNum_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.PreCreatePlayerController
struct AUAEGameMode_PreCreatePlayerController_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	class APlayerController*                           ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.OnPlayerFiring
struct AUAEGameMode_OnPlayerFiring_Params
{
	uint32_t                                           InPlayerKey;                                              // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.OnObserverLogout
struct AUAEGameMode_OnObserverLogout_Params
{
	class AUAEPlayerController*                        InController;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.OnObserverLogin
struct AUAEGameMode_OnObserverLogin_Params
{
	class AUAEPlayerController*                        InController;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.OnMsg
struct AUAEGameMode_OnMsg_Params
{
	struct FString                                     Msg;                                                      // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEGameMode.OnAirDropBoxLanded
struct AUAEGameMode_OnAirDropBoxLanded_Params
{
	int                                                boxId;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	struct FVector                                     pos;                                                      // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.OnAirDropBoxEmpty
struct AUAEGameMode_OnAirDropBoxEmpty_Params
{
	int                                                boxId;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.NotifyPlayerExit
struct AUAEGameMode_NotifyPlayerExit_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bDestroyPlayerController;                                 // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bDestroyCharacter;                                        // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bSendFailure;                                             // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     FailureMessage;                                           // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEGameMode.NotifyPlayerAbleToExitSafely
struct AUAEGameMode_NotifyPlayerAbleToExitSafely_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.NotifyGameModeInit
struct AUAEGameMode_NotifyGameModeInit_Params
{
};

// Function Gameplay.UAEGameMode.NotifyAIPlayerEnter
struct AUAEGameMode_NotifyAIPlayerEnter_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.ModifyDamage
struct AUAEGameMode_ModifyDamage_Params
{
	float                                              Damage;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	struct FDamageEvent                                DamageEvent;                                              // (ConstParm, Parm, OutParm, ReferenceParm)
	class AController*                                 EventInstigator;                                          // (Parm, ZeroConstructor, IsPlainOldData)
	class AController*                                 VictimController;                                         // (Parm, ZeroConstructor, IsPlainOldData)
	class AActor*                                      DamageCauser;                                             // (Parm, ZeroConstructor, IsPlainOldData)
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.Killed
struct AUAEGameMode_Killed_Params
{
	class AController*                                 Killer;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	class AController*                                 VictimPlayer;                                             // (Parm, ZeroConstructor, IsPlainOldData)
	class APawn*                                       VictimPawn;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	class UDamageType*                                 DamageType;                                               // (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.InitWorldActiveRange
struct AUAEGameMode_InitWorldActiveRange_Params
{
};

// Function Gameplay.UAEGameMode.InitGenerator
struct AUAEGameMode_InitGenerator_Params
{
};

// Function Gameplay.UAEGameMode.InitDynamicTriggers
struct AUAEGameMode_InitDynamicTriggers_Params
{
};

// Function Gameplay.UAEGameMode.InitDynamicBlocks
struct AUAEGameMode_InitDynamicBlocks_Params
{
};

// Function Gameplay.UAEGameMode.InitAdvertisement
struct AUAEGameMode_InitAdvertisement_Params
{
};

// Function Gameplay.UAEGameMode.HeartBeat
struct AUAEGameMode_HeartBeat_Params
{
};

// Function Gameplay.UAEGameMode.HasDynamicBlocks
struct AUAEGameMode_HasDynamicBlocks_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.HandlePlayerPaintDecalResponse
struct AUAEGameMode_HandlePlayerPaintDecalResponse_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Result;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                DecalId;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.HandlePlayerGiftItemResponse
struct AUAEGameMode_HandlePlayerGiftItemResponse_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Result;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                GiftResID;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.GotoNearDeath
struct AUAEGameMode_GotoNearDeath_Params
{
	class AController*                                 DamageInstigator;                                         // (Parm, ZeroConstructor, IsPlainOldData)
	class APawn*                                       VictimPawn;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.GetSurvivingTeamCount
struct AUAEGameMode_GetSurvivingTeamCount_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.GetSurvivingCharacterCount
struct AUAEGameMode_GetSurvivingCharacterCount_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.GetPlayerStateListWithTeamID
struct AUAEGameMode_GetPlayerStateListWithTeamID_Params
{
	int                                                TeamID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	TArray<class AUAEPlayerState*>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAEGameMode.GetPlayerControllerListWithTeamID
struct AUAEGameMode_GetPlayerControllerListWithTeamID_Params
{
	int                                                TeamID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	TArray<class AUAEPlayerController*>                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAEGameMode.GetPlayerAndRealAiNum
struct AUAEGameMode_GetPlayerAndRealAiNum_Params
{
	int                                                OutPlayerNum;                                             // (Parm, OutParm, ZeroConstructor, IsPlainOldData)
	int                                                OutRealAiNum;                                             // (Parm, OutParm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.GetObserverControllerList
struct AUAEGameMode_GetObserverControllerList_Params
{
	TArray<class AUAEPlayerController*>                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAEGameMode.FindPlayerStateWithPlayerKey
struct AUAEGameMode_FindPlayerStateWithPlayerKey_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	class AUAEPlayerState*                             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.FindPlayerControllerWithPlayerKey
struct AUAEGameMode_FindPlayerControllerWithPlayerKey_Params
{
	uint32_t                                           PlayerKey;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FName                                       PlayerType;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	class AUAEPlayerController*                        ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.DestroyNoActiveWorldActor
struct AUAEGameMode_DestroyNoActiveWorldActor_Params
{
	struct FVector                                     Location;                                                 // (Parm, OutParm, IsPlainOldData)
	float                                              Radius;                                                   // (Parm, OutParm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.DestroyCharacterForPlayerController
struct AUAEGameMode_DestroyCharacterForPlayerController_Params
{
	class APlayerController*                           PC;                                                       // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.DebugEnterFriendObserver
struct AUAEGameMode_DebugEnterFriendObserver_Params
{
	class AUAEPlayerController*                        InController;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.CollectAllPlayerInfo
struct AUAEGameMode_CollectAllPlayerInfo_Params
{
	float                                              DeltaSeconds;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.ChangeName
struct AUAEGameMode_ChangeName_Params
{
	class AController*                                 Controller;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     NewName;                                                  // (Parm, ZeroConstructor)
	bool                                               bNameChange;                                              // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEGameMode.AddAirDropBox
struct AUAEGameMode_AddAirDropBox_Params
{
	int                                                boxId;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	struct FVector                                     pos;                                                      // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.SetGVMemberIDServerCall
struct AUAEPlayerState_SetGVMemberIDServerCall_Params
{
	int                                                memberID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.SetGVMemberID
struct AUAEPlayerState_SetGVMemberID_Params
{
	int                                                memberID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.ReportTaskExtInfo
struct AUAEPlayerState_ReportTaskExtInfo_Params
{
	int                                                TaskID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     ExtInfo;                                                  // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEPlayerState.ReportTaskData
struct AUAEPlayerState_ReportTaskData_Params
{
	int                                                TaskID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                process;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.ReportSpecialCollection
struct AUAEPlayerState_ReportSpecialCollection_Params
{
	int                                                ItemID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.ReportSecretAreaID
struct AUAEPlayerState_ReportSecretAreaID_Params
{
	int                                                SecretAreaID;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.ReportLandLocType
struct AUAEPlayerState_ReportLandLocType_Params
{
	int                                                TouchDownLocType;                                         // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     TouchDownLocName;                                         // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEPlayerState.ReportLandArea
struct AUAEPlayerState_ReportLandArea_Params
{
	int                                                TouchDownArea;                                            // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.OnReportSpecificBulletUsed
struct AUAEPlayerState_OnReportSpecificBulletUsed_Params
{
	int                                                ItemID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.OnRep_UID
struct AUAEPlayerState_OnRep_UID_Params
{
};

// Function Gameplay.UAEPlayerState.OnRep_PlayerKillsChange
struct AUAEPlayerState_OnRep_PlayerKillsChange_Params
{
};

// Function Gameplay.UAEPlayerState.OnRep_MatchLabel
struct AUAEPlayerState_OnRep_MatchLabel_Params
{
};

// Function Gameplay.UAEPlayerState.OnRep_CollectItemRecord
struct AUAEPlayerState_OnRep_CollectItemRecord_Params
{
};

// Function Gameplay.UAEPlayerState.OnRep_CampID
struct AUAEPlayerState_OnRep_CampID_Params
{
};

// Function Gameplay.UAEPlayerState.IsSpecialPickItemCollectionCompleted
struct AUAEPlayerState_IsSpecialPickItemCollectionCompleted_Params
{
	int                                                ItemID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.IsSpecialPickItem
struct AUAEPlayerState_IsSpecialPickItem_Params
{
	int                                                ItemID;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.GetUserIDByMemberID
struct AUAEPlayerState_GetUserIDByMemberID_Params
{
	int                                                memberID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	uint32_t                                           ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerState.GetUIDString
struct AUAEPlayerState_GetUIDString_Params
{
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAEPlayerState.GetTeammateBattleResultData
struct AUAEPlayerState_GetTeammateBattleResultData_Params
{
	struct FGameModeTeammateBattleResultData           ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.UAEPlayerState.GetPlayerBattleResultData
struct AUAEPlayerState_GetPlayerBattleResultData_Params
{
	struct FGameModePlayerBattleResultData             ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.UAEPlayerState.ChangeCollectItemRecord
struct AUAEPlayerState_ChangeCollectItemRecord_Params
{
	int                                                InItemID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               InNewState;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.UpdatePlayerOBBattleInfo
struct AUAEPlayerController_UpdatePlayerOBBattleInfo_Params
{
	struct FString                                     UIDString;                                                // (ConstParm, Parm, ZeroConstructor)
	struct FPlayerOBBattleInfo                         NewBattleInfo;                                            // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.UAEPlayerController.TestLogout
struct AUAEPlayerController_TestLogout_Params
{
};

// Function Gameplay.UAEPlayerController.SetUsedSimulationCVar
struct AUAEPlayerController_SetUsedSimulationCVar_Params
{
	bool                                               Value;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.SetPanels
struct AUAEPlayerController_SetPanels_Params
{
	TArray<class UUAEUserWidget*>                      panels;                                                   // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
};

// Function Gameplay.UAEPlayerController.ServerTestLogout
struct AUAEPlayerController_ServerTestLogout_Params
{
};

// Function Gameplay.UAEPlayerController.ServerSetVoiceId
struct AUAEPlayerController_ServerSetVoiceId_Params
{
	int                                                VoiceID;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.ServerKickSelf
struct AUAEPlayerController_ServerKickSelf_Params
{
};

// Function Gameplay.UAEPlayerController.ServerGotoSpectating
struct AUAEPlayerController_ServerGotoSpectating_Params
{
	class APawn*                                       ViewTarget;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.ServerExitGame
struct AUAEPlayerController_ServerExitGame_Params
{
};

// Function Gameplay.UAEPlayerController.ServerAcknowledgeReconnection_2
struct AUAEPlayerController_ServerAcknowledgeReconnection_2_Params
{
	uint32_t                                           Token;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.ResetUsedSimulationCVar
struct AUAEPlayerController_ResetUsedSimulationCVar_Params
{
};

// Function Gameplay.UAEPlayerController.ReleaseInGameUI
struct AUAEPlayerController_ReleaseInGameUI_Params
{
};

// Function Gameplay.UAEPlayerController.PrintStatistics
struct AUAEPlayerController_PrintStatistics_Params
{
};

// Function Gameplay.UAEPlayerController.PlayerStartIDReceived
struct AUAEPlayerController_PlayerStartIDReceived_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_WatchPlayerKey
struct AUAEPlayerController_OnRep_WatchPlayerKey_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_UsedSimulation
struct AUAEPlayerController_OnRep_UsedSimulation_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_PlayerOBInfoList
struct AUAEPlayerController_OnRep_PlayerOBInfoList_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_LastGameResultTime
struct AUAEPlayerController_OnRep_LastGameResultTime_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_IsSpectatingEnemy
struct AUAEPlayerController_OnRep_IsSpectatingEnemy_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_IsSpectating
struct AUAEPlayerController_OnRep_IsSpectating_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_IsObserver
struct AUAEPlayerController_OnRep_IsObserver_Params
{
};

// Function Gameplay.UAEPlayerController.OnRep_FriendObservers
struct AUAEPlayerController_OnRep_FriendObservers_Params
{
};

// Function Gameplay.UAEPlayerController.KickSelf
struct AUAEPlayerController_KickSelf_Params
{
};

// Function Gameplay.UAEPlayerController.IsSpectator
struct AUAEPlayerController_IsSpectator_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsRoomMode
struct AUAEPlayerController_IsRoomMode_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsPureSpectator
struct AUAEPlayerController_IsPureSpectator_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsObserver
struct AUAEPlayerController_IsObserver_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsInSpectatingEnemy
struct AUAEPlayerController_IsInSpectatingEnemy_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsInSpectating
struct AUAEPlayerController_IsInSpectating_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsFriendOrEnemySpectator
struct AUAEPlayerController_IsFriendOrEnemySpectator_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsFriendObserver
struct AUAEPlayerController_IsFriendObserver_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsDemoRecSpectator
struct AUAEPlayerController_IsDemoRecSpectator_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.IsDemoPlaySpectator
struct AUAEPlayerController_IsDemoPlaySpectator_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.InitWithPlayerParams
struct AUAEPlayerController_InitWithPlayerParams_Params
{
	struct FGameModePlayerParams                       Params;                                                   // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.UAEPlayerController.InitWeaponAvatarItems
struct AUAEPlayerController_InitWeaponAvatarItems_Params
{
};

// Function Gameplay.UAEPlayerController.InitPlayerOBInfoList
struct AUAEPlayerController_InitPlayerOBInfoList_Params
{
};

// Function Gameplay.UAEPlayerController.InitInGameUI
struct AUAEPlayerController_InitInGameUI_Params
{
};

// Function Gameplay.UAEPlayerController.GotoSpectating
struct AUAEPlayerController_GotoSpectating_Params
{
	int                                                PlayerID;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.GetOBPlayerUIDString
struct AUAEPlayerController_GetOBPlayerUIDString_Params
{
	struct FPlayerOBInfo                               PlayerOBInfo;                                             // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAEPlayerController.GetCurrentOBPlayerKey
struct AUAEPlayerController_GetCurrentOBPlayerKey_Params
{
	uint32_t                                           ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.GetCurrentOBPlayerInfoIndex
struct AUAEPlayerController_GetCurrentOBPlayerInfoIndex_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.ExitGame
struct AUAEPlayerController_ExitGame_Params
{
};

// Function Gameplay.UAEPlayerController.ExhaustCPU
struct AUAEPlayerController_ExhaustCPU_Params
{
};

// Function Gameplay.UAEPlayerController.ExecDSCommand
struct AUAEPlayerController_ExecDSCommand_Params
{
	struct FString                                     DSCommand;                                                // (ConstParm, Parm, ZeroConstructor, ReferenceParm)
};

// Function Gameplay.UAEPlayerController.ExcuteIntRecord
struct AUAEPlayerController_ExcuteIntRecord_Params
{
	struct FString                                     Key;                                                      // (Parm, ZeroConstructor)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.ExcuteIntCounterRecord
struct AUAEPlayerController_ExcuteIntCounterRecord_Params
{
	struct FString                                     Key;                                                      // (Parm, ZeroConstructor)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.EnableInGameUI
struct AUAEPlayerController_EnableInGameUI_Params
{
};

// Function Gameplay.UAEPlayerController.DumpNetActors
struct AUAEPlayerController_DumpNetActors_Params
{
};

// Function Gameplay.UAEPlayerController.DumpAllUI
struct AUAEPlayerController_DumpAllUI_Params
{
};

// Function Gameplay.UAEPlayerController.DumpAllObjects
struct AUAEPlayerController_DumpAllObjects_Params
{
};

// Function Gameplay.UAEPlayerController.DumpAllActors
struct AUAEPlayerController_DumpAllActors_Params
{
};

// Function Gameplay.UAEPlayerController.DoCrash
struct AUAEPlayerController_DoCrash_Params
{
};

// Function Gameplay.UAEPlayerController.DisableInGameUI
struct AUAEPlayerController_DisableInGameUI_Params
{
};

// Function Gameplay.UAEPlayerController.ClientShowTeammateEscapeNotice
struct AUAEPlayerController_ClientShowTeammateEscapeNotice_Params
{
};

// Function Gameplay.UAEPlayerController.ClientInitPlayerOBInfoButton
struct AUAEPlayerController_ClientInitPlayerOBInfoButton_Params
{
};

// Function Gameplay.UAEPlayerController.ClientBroadcastRespawnComplete
struct AUAEPlayerController_ClientBroadcastRespawnComplete_Params
{
};

// Function Gameplay.UAEPlayerController.ClientBroadcastReconnectionSuccessful
struct AUAEPlayerController_ClientBroadcastReconnectionSuccessful_Params
{
};

// Function Gameplay.UAEPlayerController.ClientAcknowledgeReconnection_4
struct AUAEPlayerController_ClientAcknowledgeReconnection_4_Params
{
	uint32_t                                           Token;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.CheckPlayerOBInfoButtonInit
struct AUAEPlayerController_CheckPlayerOBInfoButtonInit_Params
{
};

// Function Gameplay.UAEPlayerController.CheckAcknowledgedPawn
struct AUAEPlayerController_CheckAcknowledgedPawn_Params
{
	class APawn*                                       InPawn;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEPlayerController.CastUIMsg
struct AUAEPlayerController_CastUIMsg_Params
{
	struct FString                                     strMsg;                                                   // (Parm, ZeroConstructor)
	struct FString                                     module;                                                   // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEPlayerController.CallLuaTableFunction
struct AUAEPlayerController_CallLuaTableFunction_Params
{
	struct FString                                     TableName;                                                // (Parm, ZeroConstructor)
	struct FString                                     FunctionName;                                             // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEPlayerController.CallLuaGlobalFunction
struct AUAEPlayerController_CallLuaGlobalFunction_Params
{
	struct FString                                     FunctionName;                                             // (Parm, ZeroConstructor)
};

// Function Gameplay.UAECharacter.RegisterAsRegionObject
struct AUAECharacter_RegisterAsRegionObject_Params
{
};

// Function Gameplay.UAECharacter.OnRep_UseWholeModel
struct AUAECharacter_OnRep_UseWholeModel_Params
{
};

// Function Gameplay.UAECharacter.OnRep_TeamID
struct AUAECharacter_OnRep_TeamID_Params
{
};

// Function Gameplay.UAECharacter.OnRep_PlayerName
struct AUAECharacter_OnRep_PlayerName_Params
{
};

// Function Gameplay.UAECharacter.OnRep_PlayerKey
struct AUAECharacter_OnRep_PlayerKey_Params
{
};

// Function Gameplay.UAECharacter.OnRep_CampID
struct AUAECharacter_OnRep_CampID_Params
{
};

// Function Gameplay.UAECharacter.NotifyPlayerActiveRegionsChanged
struct AUAECharacter_NotifyPlayerActiveRegionsChanged_Params
{
	bool                                               bEnter;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAECharacter.GetPlayerKey
struct AUAECharacter_GetPlayerKey_Params
{
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacter.GetNonSimulatedComponents_OnFighting
struct AUAECharacter_GetNonSimulatedComponents_OnFighting_Params
{
	TArray<class UActorComponent*>                     ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacter.GetNonSimulatedComponents_NonTeammates
struct AUAECharacter_GetNonSimulatedComponents_NonTeammates_Params
{
	TArray<class UActorComponent*>                     ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacter.GetNonSimulatedComponents
struct AUAECharacter_GetNonSimulatedComponents_Params
{
	TArray<class UActorComponent*>                     ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacter.GetNonDedicatedComponents
struct AUAECharacter_GetNonDedicatedComponents_Params
{
	TArray<class UActorComponent*>                     ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacter.DeactiveCameraOnSimulation
struct AUAECharacter_DeactiveCameraOnSimulation_Params
{
};

// Function Gameplay.UAECharacter.ClientAcknowledgeReconnection_3
struct AUAECharacter_ClientAcknowledgeReconnection_3_Params
{
	uint32_t                                           Token;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEHouseActor.OnRep_WindowList
struct AUAEHouseActor_OnRep_WindowList_Params
{
};

// Function Gameplay.UAEHouseActor.BroadcastWindowRepDataUpdated
struct AUAEHouseActor_BroadcastWindowRepDataUpdated_Params
{
	struct FUAEWindowRepData                           InRepData;                                                // (Parm)
};

// Function Gameplay.BackpackComponent.UseItem
struct UBackpackComponent_UseItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	struct FBattleItemUseTarget                        Target;                                                   // (Parm)
	EBattleItemUseReason                               Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.UpdateOccupiedCapacity
struct UBackpackComponent_UpdateOccupiedCapacity_Params
{
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.UpdateCapacity
struct UBackpackComponent_UpdateCapacity_Params
{
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.UnequipItem
struct UBackpackComponent_UnequipItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
};

// Function Gameplay.BackpackComponent.TryMergeItemHandles
struct UBackpackComponent_TryMergeItemHandles_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
};

// Function Gameplay.BackpackComponent.TakeItem
struct UBackpackComponent_TakeItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bCallHandleDrop;                                          // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.SwapItem
struct UBackpackComponent_SwapItem_Params
{
	struct FItemDefineID                               DefineID1;                                                // (Parm)
	struct FItemDefineID                               DefineID2;                                                // (Parm)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ServerEnableItem
struct UBackpackComponent_ServerEnableItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	bool                                               bUse;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ReturnItem
struct UBackpackComponent_ReturnItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bCallHandlePickup;                                        // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.RemoveItemHandle
struct UBackpackComponent_RemoveItemHandle_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ReceiveItemList
struct UBackpackComponent_ReceiveItemList_Params
{
};

// Function Gameplay.BackpackComponent.ReceiveCapacity
struct UBackpackComponent_ReceiveCapacity_Params
{
};

// Function Gameplay.BackpackComponent.PickupItem
struct UBackpackComponent_PickupItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	struct FBattleItemPickupInfo                       PickupInfo;                                               // (Parm)
	EBattleItemPickupReason                            Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.OnRep_specialCountLimit
struct UBackpackComponent_OnRep_specialCountLimit_Params
{
};

// Function Gameplay.BackpackComponent.OnRep_ItemListNet
struct UBackpackComponent_OnRep_ItemListNet_Params
{
};

// Function Gameplay.BackpackComponent.OnRep_ItemList
struct UBackpackComponent_OnRep_ItemList_Params
{
};

// Function Gameplay.BackpackComponent.OnRep_Capacity
struct UBackpackComponent_OnRep_Capacity_Params
{
};

// Function Gameplay.BackpackComponent.NotifyItemUpdated
struct UBackpackComponent_NotifyItemUpdated_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
};

// Function Gameplay.BackpackComponent.NotifyItemRemoved
struct UBackpackComponent_NotifyItemRemoved_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
};

// Function Gameplay.BackpackComponent.NotifyItemListUpdated
struct UBackpackComponent_NotifyItemListUpdated_Params
{
};

// Function Gameplay.BackpackComponent.NotifyCapacityUpdated
struct UBackpackComponent_NotifyCapacityUpdated_Params
{
};

// Function Gameplay.BackpackComponent.NewItemHandle
struct UBackpackComponent_NewItemHandle_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	class UBattleItemHandleBase*                       ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ModifyItemHandleEquippingState
struct UBackpackComponent_ModifyItemHandleEquippingState_Params
{
	class UItemHandleBase*                             ItemHandle;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bEquipping;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ModifyItemHandleCount
struct UBackpackComponent_ModifyItemHandleCount_Params
{
	class UItemHandleBase*                             ItemHandle;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ItemNet2Data
struct UBackpackComponent_ItemNet2Data_Params
{
	struct FNetArrayUnit                               netItem;                                                  // (ConstParm, Parm, OutParm, ReferenceParm)
	struct FBattleItemData                             ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.BackpackComponent.HasItemBySubType
struct UBackpackComponent_HasItemBySubType_Params
{
	int                                                subType;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.HasItemByDefindIdRange
struct UBackpackComponent_HasItemByDefindIdRange_Params
{
	int                                                LowValue;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                HighValue;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.GetWorld_BP
struct UBackpackComponent_GetWorld_BP_Params
{
	class UWorld*                                      ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.GetSpecialItemNow
struct UBackpackComponent_GetSpecialItemNow_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	struct FSpecialPickInfo                            ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetSpecialItemBefore
struct UBackpackComponent_GetSpecialItemBefore_Params
{
	int                                                itemResID;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FSpecialPickInfo                            ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetItemListByDefineID
struct UBackpackComponent_GetItemListByDefineID_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	TArray<struct FBattleItemData>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetItemHandleMap
struct UBackpackComponent_GetItemHandleMap_Params
{
	TMap<struct FItemDefineID, class UItemHandleBase*> ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetItemHandleList
struct UBackpackComponent_GetItemHandleList_Params
{
	TArray<class UItemHandleBase*>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetItemByDefineID
struct UBackpackComponent_GetItemByDefineID_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	struct FBattleItemData                             ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetBattleItemFeatureDataByDefineID
struct UBackpackComponent_GetBattleItemFeatureDataByDefineID_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	struct FBattleItemFeatureData                      ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.BackpackComponent.GetAllItemList
struct UBackpackComponent_GetAllItemList_Params
{
	TArray<struct FBattleItemData>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.BackpackComponent.ForceNetUpdate
struct UBackpackComponent_ForceNetUpdate_Params
{
};

// Function Gameplay.BackpackComponent.EquipItem
struct UBackpackComponent_EquipItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
};

// Function Gameplay.BackpackComponent.DropItem
struct UBackpackComponent_DropItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	EBattleItemDropReason                              Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.DisuseItem
struct UBackpackComponent_DisuseItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemDisuseReason                            Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.CreateItemHandleInternal
struct UBackpackComponent_CreateItemHandleInternal_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	class UBattleItemHandleBase*                       ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.CreateItemHandle
struct UBackpackComponent_CreateItemHandle_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	class UItemHandleBase*                             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ConsumeItem
struct UBackpackComponent_ConsumeItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ClientUpdateItemData
struct UBackpackComponent_ClientUpdateItemData_Params
{
	struct FBattleItemData                             InItemData;                                               // (ConstParm, Parm, ReferenceParm)
};

// Function Gameplay.BackpackComponent.ClientRemoveItemData
struct UBackpackComponent_ClientRemoveItemData_Params
{
	struct FBattleItemData                             InItemData;                                               // (ConstParm, Parm, ReferenceParm)
};

// Function Gameplay.BackpackComponent.ClientBroadcastItemOperationFailedDelegate
struct UBackpackComponent_ClientBroadcastItemOperationFailedDelegate_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemOperationType                           operationType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	EBattleItemOperationFailedReason                   FailedReason;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.ClientBroadcastItemOperationDelegate
struct UBackpackComponent_ClientBroadcastItemOperationDelegate_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemOperationType                           operationType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	unsigned char                                      Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.CheckCapacityForItem
struct UBackpackComponent_CheckCapacityForItem_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.CanDisuseToBackpack
struct UBackpackComponent_CanDisuseToBackpack_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.BroadcastItemOperCountDelegate
struct UBackpackComponent_BroadcastItemOperCountDelegate_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemOperationType                           operationType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.BroadcastItemOperationFailedDelegate
struct UBackpackComponent_BroadcastItemOperationFailedDelegate_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemOperationType                           operationType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	EBattleItemOperationFailedReason                   FailedReason;                                             // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.BroadcastItemOperationDelegate
struct UBackpackComponent_BroadcastItemOperationDelegate_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	EBattleItemOperationType                           operationType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	unsigned char                                      Reason;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.BackpackComponent.AddItemHandle
struct UBackpackComponent_AddItemHandle_Params
{
	struct FItemDefineID                               DefineID;                                                 // (Parm)
	class UItemHandleBase*                             ItemHandle;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.BaseGeneratorComponent.RegisterWorldTileSpot
struct UBaseGeneratorComponent_RegisterWorldTileSpot_Params
{
	class USpotSceneComponent*                         Spot;                                                     // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.BaseGeneratorComponent.RegisterSpotComponentToTick
struct UBaseGeneratorComponent_RegisterSpotComponentToTick_Params
{
	class USpotSceneComponent*                         SpotComponent;                                            // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.BaseGeneratorComponent.RegisterGroupSpotComponent
struct UBaseGeneratorComponent_RegisterGroupSpotComponent_Params
{
	class UGroupSpotSceneComponent*                    GroupSpotComponent;                                       // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.BaseGeneratorComponent.GeneratorWorldTileSpots
struct UBaseGeneratorComponent_GeneratorWorldTileSpots_Params
{
	struct FWorldTileSpotArray                         SpotArray;                                                // (Parm, OutParm)
};

// Function Gameplay.BaseGeneratorComponent.GenerateSpots
struct UBaseGeneratorComponent_GenerateSpots_Params
{
};

// Function Gameplay.BaseGeneratorComponent.GenerateSpotOnTick
struct UBaseGeneratorComponent_GenerateSpotOnTick_Params
{
};

// Function Gameplay.BaseGeneratorComponent.CheckTileLevelsVisible
struct UBaseGeneratorComponent_CheckTileLevelsVisible_Params
{
};

// Function Gameplay.GeneratorActorAIInterface.RegisterAIPickupPoint
struct UGeneratorActorAIInterface_RegisterAIPickupPoint_Params
{
	class UItemSpotSceneComponent*                     Spot;                                                     // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
	class AActor*                                      PickUpActor;                                              // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.GeneratorActorInterface.InitData
struct UGeneratorActorInterface_InitData_Params
{
	class UItemSpotSceneComponent*                     ItemSpotSceneComponent;                                   // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
	int                                                ItemCount;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     Value;                                                    // (Parm, ZeroConstructor)
	struct FString                                     Category;                                                 // (Parm, ZeroConstructor)
	bool                                               RepeatGenerateItem;                                       // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.GeneratorVehicleInterface.SetSafeSpawn
struct UGeneratorVehicleInterface_SetSafeSpawn_Params
{
	bool                                               ab_IsSafeSpawn;                                           // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.GeneratorVehicleInterface.InitVehicle
struct UGeneratorVehicleInterface_InitVehicle_Params
{
	int                                                FuelPercent;                                              // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bEngineOn;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.GlobalConfigActor.Init
struct AGlobalConfigActor_Init_Params
{
};

// Function Gameplay.GroupSpotSceneComponent.SetGroupValid
struct UGroupSpotSceneComponent_SetGroupValid_Params
{
	bool                                               Valid;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.GroupSpotSceneComponent.IsValidGroup
struct UGroupSpotSceneComponent_IsValidGroup_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.GroupSpotSceneComponent.FindWorldCompositionID
struct UGroupSpotSceneComponent_FindWorldCompositionID_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.GroupSpotSceneComponent.DoPickUp
struct UGroupSpotSceneComponent_DoPickUp_Params
{
};

// Function Gameplay.ItemConfigActorComponent.RegisterGroupSceneComponent
struct UItemConfigActorComponent_RegisterGroupSceneComponent_Params
{
	int                                                GroupType;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	class USceneComponent*                             GroupSceneComponent;                                      // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.ItemConfigActorComponent.RandomItemSpawnClass
struct UItemConfigActorComponent_RandomItemSpawnClass_Params
{
	struct FString                                     ItemValue;                                                // (Parm, ZeroConstructor)
	struct FString                                     ItemCategory;                                             // (Parm, ZeroConstructor)
	TArray<struct FItemSpawnClass>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.ItemConfigActorComponent.RandomGroupSceneComponents
struct UItemConfigActorComponent_RandomGroupSceneComponents_Params
{
	int                                                GroupType;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Persent;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	TArray<class USceneComponent*>                     ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.ItemConfigActorComponent.RandomGroupSceneComponent
struct UItemConfigActorComponent_RandomGroupSceneComponent_Params
{
	TArray<class USceneComponent*>                     AllGroups;                                                // (Parm, ZeroConstructor)
	class USceneComponent*                             ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
};

// Function Gameplay.ItemConfigActorComponent.LoadActorClass
struct UItemConfigActorComponent_LoadActorClass_Params
{
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	class UClass*                                      ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemConfigActorComponent.GetItemSpawnClass
struct UItemConfigActorComponent_GetItemSpawnClass_Params
{
	struct FItemSpawnData                              Data;                                                     // (Parm)
	TArray<struct FItemSpawnClass>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.ItemGeneratorComponent.WriteItemClassStatisticsDatas
struct UItemGeneratorComponent_WriteItemClassStatisticsDatas_Params
{
};

// Function Gameplay.ItemGeneratorComponent.WriteGroupStatisticsDatas
struct UItemGeneratorComponent_WriteGroupStatisticsDatas_Params
{
};

// Function Gameplay.ItemGeneratorComponent.WriteBuildingStatisticsDatas
struct UItemGeneratorComponent_WriteBuildingStatisticsDatas_Params
{
};

// Function Gameplay.ItemGeneratorComponent.WriteAllStatisticsDatasToLog
struct UItemGeneratorComponent_WriteAllStatisticsDatasToLog_Params
{
};

// Function Gameplay.ItemGeneratorComponent.WriteAllStatisticsDatas
struct UItemGeneratorComponent_WriteAllStatisticsDatas_Params
{
};

// Function Gameplay.ItemGeneratorComponent.SetCatetoryRate
struct UItemGeneratorComponent_SetCatetoryRate_Params
{
	TMap<struct FString, float>                        Rates;                                                    // (Parm, ZeroConstructor)
};

// Function Gameplay.ItemGeneratorComponent.RegisterItemGenerateSpawnData
struct UItemGeneratorComponent_RegisterItemGenerateSpawnData_Params
{
	struct FItemGenerateSpawnData                      Data;                                                     // (Parm)
};

// Function Gameplay.ItemGeneratorComponent.RegisterBornIslandItem
struct UItemGeneratorComponent_RegisterBornIslandItem_Params
{
	class AActor*                                      Item;                                                     // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.ItemGeneratorComponent.RandomSingleGroup
struct UItemGeneratorComponent_RandomSingleGroup_Params
{
	TArray<class UGroupSpotSceneComponent*>            Groups;                                                   // (Parm, OutParm, ZeroConstructor)
	struct FSpotGroupProperty                          GroupProperty;                                            // (ConstParm, Parm, OutParm, ReferenceParm)
	class UItemGroupSpotSceneComponent*                ReturnValue;                                              // (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
};

// Function Gameplay.ItemGeneratorComponent.RandomItemGenerateSpawnData
struct UItemGeneratorComponent_RandomItemGenerateSpawnData_Params
{
	TArray<struct FItemGenerateSpawnData>              items;                                                    // (Parm, OutParm, ZeroConstructor)
	struct FItemGenerateSpawnData                      ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.ItemGeneratorComponent.RandomGroupsByType
struct UItemGeneratorComponent_RandomGroupsByType_Params
{
	struct FSpotGroupProperty                          GroupProperty;                                            // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.ItemGeneratorComponent.RandomGroups
struct UItemGeneratorComponent_RandomGroups_Params
{
};

// Function Gameplay.ItemGeneratorComponent.RandomBornIslandGroups
struct UItemGeneratorComponent_RandomBornIslandGroups_Params
{
};

// Function Gameplay.ItemGeneratorComponent.LoadItemGenerateTable
struct UItemGeneratorComponent_LoadItemGenerateTable_Params
{
};

// Function Gameplay.ItemGeneratorComponent.IsCatetoryEnabled
struct UItemGeneratorComponent_IsCatetoryEnabled_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemGeneratorComponent.InitCatetorys
struct UItemGeneratorComponent_InitCatetorys_Params
{
};

// Function Gameplay.ItemGeneratorComponent.GetSpotGroupPropertyByGroupType
struct UItemGeneratorComponent_GetSpotGroupPropertyByGroupType_Params
{
	TEnumAsByte<ESpotGroupType>                        SpotGroupType;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	struct FSpotGroupProperty                          ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.ItemGeneratorComponent.GetRandomItemClassArray
struct UItemGeneratorComponent_GetRandomItemClassArray_Params
{
	struct FString                                     Value;                                                    // (Parm, OutParm, ZeroConstructor)
	struct FString                                     Category;                                                 // (Parm, OutParm, ZeroConstructor)
	TArray<struct FItemGenerateSpawnClass>             Results;                                                  // (Parm, OutParm, ZeroConstructor)
	bool                                               RepeatGenerateItem;                                       // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemGeneratorComponent.GetCatetoryRate
struct UItemGeneratorComponent_GetCatetoryRate_Params
{
	struct FString                                     Catetory;                                                 // (Parm, ZeroConstructor)
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemGeneratorComponent.GenerateSpotOnTick
struct UItemGeneratorComponent_GenerateSpotOnTick_Params
{
};

// Function Gameplay.ItemGeneratorComponent.DeleteValidGroups
struct UItemGeneratorComponent_DeleteValidGroups_Params
{
};

// Function Gameplay.ItemGeneratorComponent.DeleteBornIslandItems
struct UItemGeneratorComponent_DeleteBornIslandItems_Params
{
};

// Function Gameplay.ItemGroupSpotSceneComponent.SetGroupProperty
struct UItemGroupSpotSceneComponent_SetGroupProperty_Params
{
	class UItemGeneratorComponent*                     Generator;                                                // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
	struct FSpotGroupProperty                          Property;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.ItemGroupSpotSceneComponent.RepeatSpots
struct UItemGroupSpotSceneComponent_RepeatSpots_Params
{
};

// Function Gameplay.ItemGroupSpotSceneComponent.RepeatSingleSpot
struct UItemGroupSpotSceneComponent_RepeatSingleSpot_Params
{
	class UItemSpotSceneComponent*                     Spot;                                                     // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.ItemGroupSpotSceneComponent.RandomSpotByType
struct UItemGroupSpotSceneComponent_RandomSpotByType_Params
{
	TEnumAsByte<ESpotType>                             SpotType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	TArray<class UItemSpotSceneComponent*>             AllSpots;                                                 // (Parm, OutParm, ZeroConstructor)
	struct FSpotTypeProperty                           Property;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.ItemGroupSpotSceneComponent.RandomSingleSpot
struct UItemGroupSpotSceneComponent_RandomSingleSpot_Params
{
	TArray<class UItemSpotSceneComponent*>             Spots;                                                    // (Parm, OutParm, ZeroConstructor)
	struct FSpotTypeProperty                           Property;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.ItemGroupSpotSceneComponent.RandomRepeatGenerateItemCD
struct UItemGroupSpotSceneComponent_RandomRepeatGenerateItemCD_Params
{
	struct FSpotGroupProperty                          GroupProperty;                                            // (ConstParm, Parm, OutParm, ReferenceParm)
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.SpotSceneComponent.SetSpotValid
struct USpotSceneComponent_SetSpotValid_Params
{
	bool                                               Valid;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.SpotSceneComponent.LineTraceSingle
struct USpotSceneComponent_LineTraceSingle_Params
{
	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)
};

// Function Gameplay.SpotSceneComponent.IsSpotValid
struct USpotSceneComponent_IsSpotValid_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.SpotSceneComponent.GetRandomCategory
struct USpotSceneComponent_GetRandomCategory_Params
{
	TArray<struct FSpotWeight>                         SpotWeights;                                              // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.SpotSceneComponent.GenerateSpot
struct USpotSceneComponent_GenerateSpot_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.SpotSceneComponent.GenerateActor
struct USpotSceneComponent_GenerateActor_Params
{
	class UClass*                                      ActorClass;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	struct FVector                                     ActorLocation;                                            // (Parm, OutParm, IsPlainOldData)
	struct FRotator                                    ActorRotator;                                             // (Parm, OutParm, IsPlainOldData)
	ESpawnActorCollisionHandlingMethod                 SpawnActorCollisionHandlingMethod;                        // (Parm, ZeroConstructor, IsPlainOldData)
	class AActor*                                      ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemSpotSceneComponent.SetSpotProperty
struct UItemSpotSceneComponent_SetSpotProperty_Params
{
	int                                                CompositionID;                                            // (Parm, ZeroConstructor, IsPlainOldData)
	TEnumAsByte<ESpotGroupType>                        GroupType;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	class UItemGeneratorComponent*                     Generator;                                                // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
	struct FSpotTypeProperty                           Property;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
	class UGroupSpotSceneComponent*                    Component;                                                // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
	bool                                               RepeatGenerateItem;                                       // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.ItemSpotSceneComponent.RepeatSpotProperty
struct UItemSpotSceneComponent_RepeatSpotProperty_Params
{
	struct FSpotTypeProperty                           Property;                                                 // (ConstParm, Parm, OutParm, ReferenceParm)
};

// Function Gameplay.ItemSpotSceneComponent.GenerateSpot
struct UItemSpotSceneComponent_GenerateSpot_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.ItemSpotSceneComponent.GenerateItems
struct UItemSpotSceneComponent_GenerateItems_Params
{
	TArray<struct FItemGenerateSpawnClass>             AllItemClass;                                             // (Parm, OutParm, ZeroConstructor)
};

// Function Gameplay.ItemSpotSceneComponent.DoPickUp
struct UItemSpotSceneComponent_DoPickUp_Params
{
	struct FString                                     ItemValue;                                                // (Parm, ZeroConstructor)
	struct FString                                     ItemCategory;                                             // (Parm, ZeroConstructor)
};

// Function Gameplay.ItemSpotSceneComponent.CountCacheItemValeCategory
struct UItemSpotSceneComponent_CountCacheItemValeCategory_Params
{
	int                                                ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEAdvertisementActor.OnRequestImgSuccess
struct AUAEAdvertisementActor_OnRequestImgSuccess_Params
{
	class UTexture2D*                                  Texture;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     RequestedURL;                                             // (Parm, ZeroConstructor)
};

// Function Gameplay.UAEAdvertisementActor.OnRep_PicURL
struct AUAEAdvertisementActor_OnRep_PicURL_Params
{
};

// Function Gameplay.UAEAdvertisementActor.OnRep_MeshPath
struct AUAEAdvertisementActor_OnRep_MeshPath_Params
{
};

// Function Gameplay.UAECharacterAnimListComponent.OnAsyncLoadingFinished
struct UUAECharacterAnimListComponent_OnAsyncLoadingFinished_Params
{
	struct FAsyncLoadCharAnimParams                    LoadingParam;                                             // (Parm)
};

// Function Gameplay.UAECharacterAnimListComponent.GetCharacterJumpAnim
struct UUAECharacterAnimListComponent_GetCharacterJumpAnim_Params
{
	TEnumAsByte<ECharacterJumpType>                    JumpType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	TArray<struct FPlayerAnimData>                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.UAECharacterAnimListComponent.GetCharacterAnim
struct UUAECharacterAnimListComponent_GetCharacterAnim_Params
{
	TEnumAsByte<ECharacterAnimType>                    AnimType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	TEnumAsByte<ECharacterPoseType>                    PoseType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	class UAnimationAsset*                             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.AELobbyCharAnimListComp.OnAsyncLoadingFinished
struct UAELobbyCharAnimListComp_OnAsyncLoadingFinished_Params
{
	struct FAsyncLoadCharAnimParams                    LoadingParam;                                             // (Parm)
};

// Function Gameplay.AELobbyCharAnimListComp.GetCharacterAnim
struct UAELobbyCharAnimListComp_GetCharacterAnim_Params
{
	TEnumAsByte<ECharacterAnimType>                    AnimType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	TEnumAsByte<ECharacterPoseType>                    PoseType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	class UAnimationAsset*                             ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEProjectile.WorkAsBuffApplierEvent
struct AUAEProjectile_WorkAsBuffApplierEvent_Params
{
	struct FString                                     BuffName;                                                 // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
	class APawn*                                       BuffTarget;                                               // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEProjectile.SetActorInitialRelativeOffset
struct AUAEProjectile_SetActorInitialRelativeOffset_Params
{
	struct FVector                                     Offset;                                                   // (Parm, IsPlainOldData)
	struct FVector                                     StandOffset;                                              // (Parm, IsPlainOldData)
	struct FVector                                     CrouchOffset;                                             // (Parm, IsPlainOldData)
	struct FVector                                     ProneOffset;                                              // (Parm, IsPlainOldData)
	TEnumAsByte<ECharacterPoseType>                    PrevoisOwnerPose;                                         // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEProjectile.OnRep_IsServerAlreadyExplodedCpp
struct AUAEProjectile_OnRep_IsServerAlreadyExplodedCpp_Params
{
};

// Function Gameplay.UAEProjectile.IsServerAlreadyExplodedCppNotify
struct AUAEProjectile_IsServerAlreadyExplodedCppNotify_Params
{
};

// Function Gameplay.UAEProjectile.IsOwnerAutomous
struct AUAEProjectile_IsOwnerAutomous_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEProjectile.GlassDetect
struct AUAEProjectile_GlassDetect_Params
{
	struct FVector                                     Start;                                                    // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
	struct FVector                                     End;                                                      // (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
};

// Function Gameplay.UAEProjectile.GetRemainingEffectTime
struct AUAEProjectile_GetRemainingEffectTime_Params
{
	float                                              ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.UAEWindowComponent.NotifyServerBroken
struct UUAEWindowComponent_NotifyServerBroken_Params
{
};

// Function Gameplay.UAEWindowComponent.NotifyRepDataUpdated
struct UUAEWindowComponent_NotifyRepDataUpdated_Params
{
	bool                                               bInitial;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bLocal;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEWindowComponent.LocalHandleWindowBrokenBP
struct UUAEWindowComponent_LocalHandleWindowBrokenBP_Params
{
	bool                                               bInitial;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bLocal;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEWindowComponent.LocalHandleWindowBroken
struct UUAEWindowComponent_LocalHandleWindowBroken_Params
{
	bool                                               bInitial;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bLocal;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEWindowComponent.HandleBroken
struct UUAEWindowComponent_HandleBroken_Params
{
	class APlayerController*                           Instigator;                                               // (Parm, ZeroConstructor, IsPlainOldData)
	bool                                               bLocal;                                                   // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.UAEWindowComponent.GetRepData
struct UUAEWindowComponent_GetRepData_Params
{
	struct FUAEWindowRepData                           ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleConfigActorComponent.LoadActorClass
struct UVehicleConfigActorComponent_LoadActorClass_Params
{
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	class UClass*                                      ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.WriteVehicleSpotStatisticsDatas
struct UVehicleAndTreasureBoxGeneratorComponent_WriteVehicleSpotStatisticsDatas_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.WriteVehicleClassStatisticsDatas
struct UVehicleAndTreasureBoxGeneratorComponent_WriteVehicleClassStatisticsDatas_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.WriteAllVehicleStatisticsDatasToLog
struct UVehicleAndTreasureBoxGeneratorComponent_WriteAllVehicleStatisticsDatasToLog_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.WriteAllVehicleStatisticsDatas
struct UVehicleAndTreasureBoxGeneratorComponent_WriteAllVehicleStatisticsDatas_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RegisterVehicleGenerateSpawnData
struct UVehicleAndTreasureBoxGeneratorComponent_RegisterVehicleGenerateSpawnData_Params
{
	struct FVehicleGenerateSpawnData                   Data;                                                     // (Parm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RegisterGroupSpotComponent
struct UVehicleAndTreasureBoxGeneratorComponent_RegisterGroupSpotComponent_Params
{
	class UGroupSpotSceneComponent*                    GroupSpotComponent;                                       // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RandomTreasureBoxSpotsByType
struct UVehicleAndTreasureBoxGeneratorComponent_RandomTreasureBoxSpotsByType_Params
{
	struct FTreasureBoxSpotProperty                    Property;                                                 // (Parm, OutParm)
	struct FVehicleSpotComponentArray                  Spots;                                                    // (Parm, OutParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RandomTreasureBoxSingleSpots
struct UVehicleAndTreasureBoxGeneratorComponent_RandomTreasureBoxSingleSpots_Params
{
	TArray<class UVehicleSpotSceneComponent*>          AllSpots;                                                 // (Parm, OutParm, ZeroConstructor)
	struct FTreasureBoxSpotProperty                    Property;                                                 // (Parm, OutParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RandomSpotsByType
struct UVehicleAndTreasureBoxGeneratorComponent_RandomSpotsByType_Params
{
	struct FVehicleSpotProperty                        Property;                                                 // (Parm, OutParm)
	struct FVehicleSpotComponentArray                  Spots;                                                    // (Parm, OutParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RandomSingleSpots
struct UVehicleAndTreasureBoxGeneratorComponent_RandomSingleSpots_Params
{
	TArray<class UVehicleSpotSceneComponent*>          AllSpots;                                                 // (Parm, OutParm, ZeroConstructor)
	struct FVehicleSpotProperty                        Property;                                                 // (Parm, OutParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.RandomGroups
struct UVehicleAndTreasureBoxGeneratorComponent_RandomGroups_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.LoadVehicleGenerateTable
struct UVehicleAndTreasureBoxGeneratorComponent_LoadVehicleGenerateTable_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GetVehicleSpotRandomInfoBySpotType
struct UVehicleAndTreasureBoxGeneratorComponent_GetVehicleSpotRandomInfoBySpotType_Params
{
	TEnumAsByte<ESpotType>                             SpotType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	struct FVehicleGenerateRandomInfo                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GetVehicleSpotRandomInfo
struct UVehicleAndTreasureBoxGeneratorComponent_GetVehicleSpotRandomInfo_Params
{
	struct FVehicleSpotProperty                        SpotProperty;                                             // (Parm, OutParm)
	struct FVehicleGenerateRandomInfo                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GetTreasureBoxSpotRandomInfo
struct UVehicleAndTreasureBoxGeneratorComponent_GetTreasureBoxSpotRandomInfo_Params
{
	struct FTreasureBoxSpotProperty                    SpotProperty;                                             // (Parm, OutParm)
	struct FVehicleGenerateRandomInfo                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GetRandomVehicleClass
struct UVehicleAndTreasureBoxGeneratorComponent_GetRandomVehicleClass_Params
{
	struct FString                                     Category;                                                 // (Parm, ZeroConstructor)
	struct FVehicleGenerateSpawnData                   ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GetRandomCategory
struct UVehicleAndTreasureBoxGeneratorComponent_GetRandomCategory_Params
{
	TArray<struct FSpotWeight>                         SpotWeights;                                              // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.GenerateSpotOnTick
struct UVehicleAndTreasureBoxGeneratorComponent_GenerateSpotOnTick_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.DeleteGroups
struct UVehicleAndTreasureBoxGeneratorComponent_DeleteGroups_Params
{
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.AddVehicleSpotCount
struct UVehicleAndTreasureBoxGeneratorComponent_AddVehicleSpotCount_Params
{
	TEnumAsByte<ESpotType>                             SpotType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	float                                              LocationX;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	float                                              LocationY;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	float                                              LocationZ;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.VehicleAndTreasureBoxGeneratorComponent.AddVehicleClassCount
struct UVehicleAndTreasureBoxGeneratorComponent_AddVehicleClassCount_Params
{
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	bool                                               IsValid;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.VehicleGeneratorComponent.WriteVehicleSpotStatisticsDatas
struct UVehicleGeneratorComponent_WriteVehicleSpotStatisticsDatas_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.WriteVehicleClassStatisticsDatas
struct UVehicleGeneratorComponent_WriteVehicleClassStatisticsDatas_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.WriteAllVehicleStatisticsDatas
struct UVehicleGeneratorComponent_WriteAllVehicleStatisticsDatas_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.RegisterVehicleGenerateSpawnData
struct UVehicleGeneratorComponent_RegisterVehicleGenerateSpawnData_Params
{
	struct FVehicleGenerateSpawnData                   Data;                                                     // (Parm)
};

// Function Gameplay.VehicleGeneratorComponent.RegisterGroupSpotComponent
struct UVehicleGeneratorComponent_RegisterGroupSpotComponent_Params
{
	class UGroupSpotSceneComponent*                    GroupSpotComponent;                                       // (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
};

// Function Gameplay.VehicleGeneratorComponent.RandomSpotsByType
struct UVehicleGeneratorComponent_RandomSpotsByType_Params
{
	struct FVehicleSpotProperty                        Property;                                                 // (Parm, OutParm)
	struct FVehicleSpotComponentArray                  Spots;                                                    // (Parm, OutParm)
};

// Function Gameplay.VehicleGeneratorComponent.RandomSingleSpots
struct UVehicleGeneratorComponent_RandomSingleSpots_Params
{
	TArray<class UVehicleSpotSceneComponent*>          AllSpots;                                                 // (Parm, OutParm, ZeroConstructor)
	struct FVehicleSpotProperty                        Property;                                                 // (Parm, OutParm)
};

// Function Gameplay.VehicleGeneratorComponent.RandomGroups
struct UVehicleGeneratorComponent_RandomGroups_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.LoadVehicleGenerateTable
struct UVehicleGeneratorComponent_LoadVehicleGenerateTable_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.GetVehicleSpotRandomInfoBySpotType
struct UVehicleGeneratorComponent_GetVehicleSpotRandomInfoBySpotType_Params
{
	TEnumAsByte<ESpotType>                             SpotType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	struct FVehicleGenerateRandomInfo                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleGeneratorComponent.GetVehicleSpotRandomInfo
struct UVehicleGeneratorComponent_GetVehicleSpotRandomInfo_Params
{
	struct FVehicleSpotProperty                        SpotProperty;                                             // (Parm, OutParm)
	struct FVehicleGenerateRandomInfo                  ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleGeneratorComponent.GetRandomVehicleClass
struct UVehicleGeneratorComponent_GetRandomVehicleClass_Params
{
	struct FString                                     Category;                                                 // (Parm, ZeroConstructor)
	struct FVehicleGenerateSpawnData                   ReturnValue;                                              // (Parm, OutParm, ReturnParm)
};

// Function Gameplay.VehicleGeneratorComponent.GetRandomCategory
struct UVehicleGeneratorComponent_GetRandomCategory_Params
{
	TArray<struct FSpotWeight>                         SpotWeights;                                              // (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
	struct FString                                     ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm)
};

// Function Gameplay.VehicleGeneratorComponent.GenerateSpotOnTick
struct UVehicleGeneratorComponent_GenerateSpotOnTick_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.DeleteGroups
struct UVehicleGeneratorComponent_DeleteGroups_Params
{
};

// Function Gameplay.VehicleGeneratorComponent.AddVehicleSpotCount
struct UVehicleGeneratorComponent_AddVehicleSpotCount_Params
{
	TEnumAsByte<ESpotType>                             SpotType;                                                 // (Parm, ZeroConstructor, IsPlainOldData)
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	float                                              LocationX;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	float                                              LocationY;                                                // (Parm, ZeroConstructor, IsPlainOldData)
	float                                              LocationZ;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.VehicleGeneratorComponent.AddVehicleClassCount
struct UVehicleGeneratorComponent_AddVehicleClassCount_Params
{
	struct FString                                     Path;                                                     // (Parm, ZeroConstructor)
	bool                                               IsValid;                                                  // (Parm, ZeroConstructor, IsPlainOldData)
	int                                                Count;                                                    // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.VehicleSpotSceneComponent.SetSpotRandomInfo
struct UVehicleSpotSceneComponent_SetSpotRandomInfo_Params
{
	struct FVehicleGenerateRandomInfo                  RandomInfo;                                               // (Parm, OutParm)
};

// Function Gameplay.VehicleSpotSceneComponent.GenerateSpot
struct UVehicleSpotSceneComponent_GenerateSpot_Params
{
	bool                                               ReturnValue;                                              // (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
};

// Function Gameplay.WeatherConfigComponent.UnloadStreamLevel
struct UWeatherConfigComponent_UnloadStreamLevel_Params
{
	struct FString                                     LevelName;                                                // (Parm, ZeroConstructor)
};

// Function Gameplay.WeatherConfigComponent.SyncWeatherLevelInfo
struct UWeatherConfigComponent_SyncWeatherLevelInfo_Params
{
};

// Function Gameplay.WeatherConfigComponent.OnUnLoadStreamLevelCompleted
struct UWeatherConfigComponent_OnUnLoadStreamLevelCompleted_Params
{
};

// Function Gameplay.WeatherConfigComponent.OnRep_WeatherSyncCount
struct UWeatherConfigComponent_OnRep_WeatherSyncCount_Params
{
};

// Function Gameplay.WeatherConfigComponent.OnLoadStreamLevelCompleted
struct UWeatherConfigComponent_OnLoadStreamLevelCompleted_Params
{
};

// Function Gameplay.WeatherConfigComponent.LoadWeatherLevel
struct UWeatherConfigComponent_LoadWeatherLevel_Params
{
};

// Function Gameplay.WeatherConfigComponent.LoadStreamLevel
struct UWeatherConfigComponent_LoadStreamLevel_Params
{
	struct FString                                     LevelName;                                                // (Parm, ZeroConstructor)
	int                                                WeatherID;                                                // (Parm, ZeroConstructor, IsPlainOldData)
};

// Function Gameplay.WeatherConfigComponent.LoadDefaultWeatherLevel
struct UWeatherConfigComponent_LoadDefaultWeatherLevel_Params
{
};

// Function Gameplay.WeatherConfigComponent.Init
struct UWeatherConfigComponent_Init_Params
{
};

}