gcdsfh145
1187 lines
48 KiB
C++
Executable File
1187 lines
48 KiB
C++
Executable File
//PUBGM(0.13.5)32位SDK
|
|
//作者:清华
|
|
//Telegram:@qinghuanb666
|
|
//生成时间:Fri Apr 18 20:44:40 2025
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
//Functions
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Function OnlineSubsystemUtils.AchievementBlueprintLibrary.GetCachedAchievementProgress
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName AchievementID (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFoundID (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Progress (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAchievementBlueprintLibrary::GetCachedAchievementProgress(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FName& AchievementID, bool* bFoundID, float* Progress)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.AchievementBlueprintLibrary.GetCachedAchievementProgress");
|
|
|
|
UAchievementBlueprintLibrary_GetCachedAchievementProgress_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.AchievementID = AchievementID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (bFoundID != nullptr)
|
|
*bFoundID = params.bFoundID;
|
|
if (Progress != nullptr)
|
|
*Progress = params.Progress;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.AchievementBlueprintLibrary.GetCachedAchievementDescription
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName AchievementID (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFoundID (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText Title (Parm, OutParm)
|
|
// struct FText LockedDescription (Parm, OutParm)
|
|
// struct FText UnlockedDescription (Parm, OutParm)
|
|
// bool bHidden (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAchievementBlueprintLibrary::GetCachedAchievementDescription(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FName& AchievementID, bool* bFoundID, struct FText* Title, struct FText* LockedDescription, struct FText* UnlockedDescription, bool* bHidden)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.AchievementBlueprintLibrary.GetCachedAchievementDescription");
|
|
|
|
UAchievementBlueprintLibrary_GetCachedAchievementDescription_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.AchievementID = AchievementID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (bFoundID != nullptr)
|
|
*bFoundID = params.bFoundID;
|
|
if (Title != nullptr)
|
|
*Title = params.Title;
|
|
if (LockedDescription != nullptr)
|
|
*LockedDescription = params.LockedDescription;
|
|
if (UnlockedDescription != nullptr)
|
|
*UnlockedDescription = params.UnlockedDescription;
|
|
if (bHidden != nullptr)
|
|
*bHidden = params.bHidden;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.AchievementQueryCallbackProxy.CacheAchievements
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAchievementQueryCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAchievementQueryCallbackProxy* UAchievementQueryCallbackProxy::CacheAchievements(class UObject* WorldContextObject, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.AchievementQueryCallbackProxy.CacheAchievements");
|
|
|
|
UAchievementQueryCallbackProxy_CacheAchievements_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.AchievementQueryCallbackProxy.CacheAchievementDescriptions
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAchievementQueryCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAchievementQueryCallbackProxy* UAchievementQueryCallbackProxy::CacheAchievementDescriptions(class UObject* WorldContextObject, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.AchievementQueryCallbackProxy.CacheAchievementDescriptions");
|
|
|
|
UAchievementQueryCallbackProxy_CacheAchievementDescriptions_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.AchievementWriteCallbackProxy.WriteAchievementProgress
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName AchievementName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Progress (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int UserTag (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAchievementWriteCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAchievementWriteCallbackProxy* UAchievementWriteCallbackProxy::WriteAchievementProgress(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FName& AchievementName, float Progress, int UserTag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.AchievementWriteCallbackProxy.WriteAchievementProgress");
|
|
|
|
UAchievementWriteCallbackProxy_WriteAchievementProgress_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.AchievementName = AchievementName;
|
|
params.Progress = Progress;
|
|
params.UserTag = UserTag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.ConnectionCallbackProxy.ConnectToService
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UConnectionCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UConnectionCallbackProxy* UConnectionCallbackProxy::ConnectToService(class UObject* WorldContextObject, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.ConnectionCallbackProxy.ConnectToService");
|
|
|
|
UConnectionCallbackProxy_ConnectToService_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.CreateSessionCallbackProxy.CreateSession
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PublicConnections (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseLAN (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCreateSessionCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCreateSessionCallbackProxy* UCreateSessionCallbackProxy::CreateSession(class UObject* WorldContextObject, class APlayerController* PlayerController, int PublicConnections, bool bUseLAN)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.CreateSessionCallbackProxy.CreateSession");
|
|
|
|
UCreateSessionCallbackProxy_CreateSession_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.PublicConnections = PublicConnections;
|
|
params.bUseLAN = bUseLAN;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.DestroySessionCallbackProxy.DestroySession
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDestroySessionCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UDestroySessionCallbackProxy* UDestroySessionCallbackProxy::DestroySession(class UObject* WorldContextObject, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.DestroySessionCallbackProxy.DestroySession");
|
|
|
|
UDestroySessionCallbackProxy_DestroySession_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.EndMatchCallbackProxy.EndMatch
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TScriptInterface<class UTurnBasedMatchInterface> MatchActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// TEnumAsByte<EMPMatchOutcome> LocalPlayerOutcome (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EMPMatchOutcome> OtherPlayersOutcome (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UEndMatchCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UEndMatchCallbackProxy* UEndMatchCallbackProxy::EndMatch(class UObject* WorldContextObject, class APlayerController* PlayerController, const TScriptInterface<class UTurnBasedMatchInterface>& MatchActor, const struct FString& MatchID, TEnumAsByte<EMPMatchOutcome> LocalPlayerOutcome, TEnumAsByte<EMPMatchOutcome> OtherPlayersOutcome)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.EndMatchCallbackProxy.EndMatch");
|
|
|
|
UEndMatchCallbackProxy_EndMatch_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchActor = MatchActor;
|
|
params.MatchID = MatchID;
|
|
params.LocalPlayerOutcome = LocalPlayerOutcome;
|
|
params.OtherPlayersOutcome = OtherPlayersOutcome;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.EndTurnCallbackProxy.EndTurn
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// TScriptInterface<class UTurnBasedMatchInterface> TurnBasedMatchInterface (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UEndTurnCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UEndTurnCallbackProxy* UEndTurnCallbackProxy::EndTurn(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FString& MatchID, const TScriptInterface<class UTurnBasedMatchInterface>& TurnBasedMatchInterface)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.EndTurnCallbackProxy.EndTurn");
|
|
|
|
UEndTurnCallbackProxy_EndTurn_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchID = MatchID;
|
|
params.TurnBasedMatchInterface = TurnBasedMatchInterface;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetServerName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlueprintSessionResult Result (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UFindSessionsCallbackProxy::GetServerName(const struct FBlueprintSessionResult& Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetServerName");
|
|
|
|
UFindSessionsCallbackProxy_GetServerName_Params params;
|
|
params.Result = Result;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetPingInMs
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlueprintSessionResult Result (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UFindSessionsCallbackProxy::GetPingInMs(const struct FBlueprintSessionResult& Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetPingInMs");
|
|
|
|
UFindSessionsCallbackProxy_GetPingInMs_Params params;
|
|
params.Result = Result;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetMaxPlayers
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlueprintSessionResult Result (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UFindSessionsCallbackProxy::GetMaxPlayers(const struct FBlueprintSessionResult& Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetMaxPlayers");
|
|
|
|
UFindSessionsCallbackProxy_GetMaxPlayers_Params params;
|
|
params.Result = Result;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetCurrentPlayers
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlueprintSessionResult Result (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UFindSessionsCallbackProxy::GetCurrentPlayers(const struct FBlueprintSessionResult& Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindSessionsCallbackProxy.GetCurrentPlayers");
|
|
|
|
UFindSessionsCallbackProxy_GetCurrentPlayers_Params params;
|
|
params.Result = Result;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindSessionsCallbackProxy.FindSessions
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxResults (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseLAN (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UFindSessionsCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UFindSessionsCallbackProxy* UFindSessionsCallbackProxy::FindSessions(class UObject* WorldContextObject, class APlayerController* PlayerController, int MaxResults, bool bUseLAN)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindSessionsCallbackProxy.FindSessions");
|
|
|
|
UFindSessionsCallbackProxy_FindSessions_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MaxResults = MaxResults;
|
|
params.bUseLAN = bUseLAN;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.FindTurnBasedMatchCallbackProxy.FindTurnBasedMatch
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TScriptInterface<class UTurnBasedMatchInterface> MatchActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinPlayers (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxPlayers (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PlayerGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ShowExistingMatches (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UFindTurnBasedMatchCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UFindTurnBasedMatchCallbackProxy* UFindTurnBasedMatchCallbackProxy::FindTurnBasedMatch(class UObject* WorldContextObject, class APlayerController* PlayerController, const TScriptInterface<class UTurnBasedMatchInterface>& MatchActor, int MinPlayers, int MaxPlayers, int PlayerGroup, bool ShowExistingMatches)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.FindTurnBasedMatchCallbackProxy.FindTurnBasedMatch");
|
|
|
|
UFindTurnBasedMatchCallbackProxy_FindTurnBasedMatch_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchActor = MatchActor;
|
|
params.MinPlayers = MinPlayers;
|
|
params.MaxPlayers = MaxPlayers;
|
|
params.PlayerGroup = PlayerGroup;
|
|
params.ShowExistingMatches = ShowExistingMatches;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.InAppPurchaseCallbackProxy.CreateProxyObjectForInAppPurchase
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FInAppPurchaseProductRequest ProductRequest (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UInAppPurchaseCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UInAppPurchaseCallbackProxy* UInAppPurchaseCallbackProxy::CreateProxyObjectForInAppPurchase(class APlayerController* PlayerController, const struct FInAppPurchaseProductRequest& ProductRequest)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.InAppPurchaseCallbackProxy.CreateProxyObjectForInAppPurchase");
|
|
|
|
UInAppPurchaseCallbackProxy_CreateProxyObjectForInAppPurchase_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.ProductRequest = ProductRequest;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.InAppPurchaseQueryCallbackProxy.CreateProxyObjectForInAppPurchaseQuery
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FString> ProductIdentifiers (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UInAppPurchaseQueryCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UInAppPurchaseQueryCallbackProxy* UInAppPurchaseQueryCallbackProxy::CreateProxyObjectForInAppPurchaseQuery(class APlayerController* PlayerController, TArray<struct FString> ProductIdentifiers)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.InAppPurchaseQueryCallbackProxy.CreateProxyObjectForInAppPurchaseQuery");
|
|
|
|
UInAppPurchaseQueryCallbackProxy_CreateProxyObjectForInAppPurchaseQuery_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.ProductIdentifiers = ProductIdentifiers;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.InAppPurchaseRestoreCallbackProxy.CreateProxyObjectForInAppPurchaseRestore
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FInAppPurchaseProductRequest> ConsumableProductFlags (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UInAppPurchaseRestoreCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UInAppPurchaseRestoreCallbackProxy* UInAppPurchaseRestoreCallbackProxy::CreateProxyObjectForInAppPurchaseRestore(TArray<struct FInAppPurchaseProductRequest> ConsumableProductFlags, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.InAppPurchaseRestoreCallbackProxy.CreateProxyObjectForInAppPurchaseRestore");
|
|
|
|
UInAppPurchaseRestoreCallbackProxy_CreateProxyObjectForInAppPurchaseRestore_Params params;
|
|
params.ConsumableProductFlags = ConsumableProductFlags;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.JoinSessionCallbackProxy.JoinSession
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FBlueprintSessionResult SearchResult (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UJoinSessionCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UJoinSessionCallbackProxy* UJoinSessionCallbackProxy::JoinSession(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FBlueprintSessionResult& SearchResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.JoinSessionCallbackProxy.JoinSession");
|
|
|
|
UJoinSessionCallbackProxy_JoinSession_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.SearchResult = SearchResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.LeaderboardBlueprintLibrary.WriteLeaderboardInteger
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName StatName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StatValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ULeaderboardBlueprintLibrary::WriteLeaderboardInteger(class APlayerController* PlayerController, const struct FName& StatName, int StatValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.LeaderboardBlueprintLibrary.WriteLeaderboardInteger");
|
|
|
|
ULeaderboardBlueprintLibrary_WriteLeaderboardInteger_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.StatName = StatName;
|
|
params.StatValue = StatValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.LeaderboardFlushCallbackProxy.CreateProxyObjectForFlush
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SessionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ULeaderboardFlushCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULeaderboardFlushCallbackProxy* ULeaderboardFlushCallbackProxy::CreateProxyObjectForFlush(class APlayerController* PlayerController, const struct FName& SessionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.LeaderboardFlushCallbackProxy.CreateProxyObjectForFlush");
|
|
|
|
ULeaderboardFlushCallbackProxy_CreateProxyObjectForFlush_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.SessionName = SessionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.LeaderboardQueryCallbackProxy.CreateProxyObjectForIntQuery
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName StatName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ULeaderboardQueryCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULeaderboardQueryCallbackProxy* ULeaderboardQueryCallbackProxy::CreateProxyObjectForIntQuery(class APlayerController* PlayerController, const struct FName& StatName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.LeaderboardQueryCallbackProxy.CreateProxyObjectForIntQuery");
|
|
|
|
ULeaderboardQueryCallbackProxy_CreateProxyObjectForIntQuery_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.StatName = StatName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.LogoutCallbackProxy.Logout
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ULogoutCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULogoutCallbackProxy* ULogoutCallbackProxy::Logout(class UObject* WorldContextObject, class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.LogoutCallbackProxy.Logout");
|
|
|
|
ULogoutCallbackProxy_Logout_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.OnlineBeaconClient.ClientOnConnected
|
|
// (Final, Net, NetReliable, Native, Event, Private, NetClient)
|
|
|
|
void AOnlineBeaconClient::ClientOnConnected()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.OnlineBeaconClient.ClientOnConnected");
|
|
|
|
AOnlineBeaconClient_ClientOnConnected_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ServerUpdateReservationRequest
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FString SessionId (Parm, ZeroConstructor)
|
|
// struct FPartyReservation ReservationUpdate (ConstParm, Parm, ReferenceParm)
|
|
|
|
void APartyBeaconClient::ServerUpdateReservationRequest(const struct FString& SessionId, const struct FPartyReservation& ReservationUpdate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ServerUpdateReservationRequest");
|
|
|
|
APartyBeaconClient_ServerUpdateReservationRequest_Params params;
|
|
params.SessionId = SessionId;
|
|
params.ReservationUpdate = ReservationUpdate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ServerReservationRequest
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FString SessionId (Parm, ZeroConstructor)
|
|
// struct FPartyReservation Reservation (ConstParm, Parm, ReferenceParm)
|
|
|
|
void APartyBeaconClient::ServerReservationRequest(const struct FString& SessionId, const struct FPartyReservation& Reservation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ServerReservationRequest");
|
|
|
|
APartyBeaconClient_ServerReservationRequest_Params params;
|
|
params.SessionId = SessionId;
|
|
params.Reservation = Reservation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ServerCancelReservationRequest
|
|
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl PartyLeader (ConstParm, Parm, ReferenceParm)
|
|
|
|
void APartyBeaconClient::ServerCancelReservationRequest(const struct FUniqueNetIdRepl& PartyLeader)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ServerCancelReservationRequest");
|
|
|
|
APartyBeaconClient_ServerCancelReservationRequest_Params params;
|
|
params.PartyLeader = PartyLeader;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ClientSendReservationUpdates
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// int NumRemainingReservations (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APartyBeaconClient::ClientSendReservationUpdates(int NumRemainingReservations)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ClientSendReservationUpdates");
|
|
|
|
APartyBeaconClient_ClientSendReservationUpdates_Params params;
|
|
params.NumRemainingReservations = NumRemainingReservations;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ClientSendReservationFull
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APartyBeaconClient::ClientSendReservationFull()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ClientSendReservationFull");
|
|
|
|
APartyBeaconClient_ClientSendReservationFull_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ClientReservationResponse
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// TEnumAsByte<EPartyReservationResult> ReservationResponse (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APartyBeaconClient::ClientReservationResponse(TEnumAsByte<EPartyReservationResult> ReservationResponse)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ClientReservationResponse");
|
|
|
|
APartyBeaconClient_ClientReservationResponse_Params params;
|
|
params.ReservationResponse = ReservationResponse;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.PartyBeaconClient.ClientCancelReservationResponse
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// TEnumAsByte<EPartyReservationResult> ReservationResponse (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APartyBeaconClient::ClientCancelReservationResponse(TEnumAsByte<EPartyReservationResult> ReservationResponse)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.PartyBeaconClient.ClientCancelReservationResponse");
|
|
|
|
APartyBeaconClient_ClientCancelReservationResponse_Params params;
|
|
params.ReservationResponse = ReservationResponse;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.QuitMatchCallbackProxy.QuitMatch
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// TEnumAsByte<EMPMatchOutcome> Outcome (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TurnTimeoutInSeconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UQuitMatchCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UQuitMatchCallbackProxy* UQuitMatchCallbackProxy::QuitMatch(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FString& MatchID, TEnumAsByte<EMPMatchOutcome> Outcome, int TurnTimeoutInSeconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.QuitMatchCallbackProxy.QuitMatch");
|
|
|
|
UQuitMatchCallbackProxy_QuitMatch_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchID = MatchID;
|
|
params.Outcome = Outcome;
|
|
params.TurnTimeoutInSeconds = TurnTimeoutInSeconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.ShowLoginUICallbackProxy.ShowExternalLoginUI
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* InPlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UShowLoginUICallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UShowLoginUICallbackProxy* UShowLoginUICallbackProxy::ShowExternalLoginUI(class UObject* WorldContextObject, class APlayerController* InPlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.ShowLoginUICallbackProxy.ShowExternalLoginUI");
|
|
|
|
UShowLoginUICallbackProxy_ShowExternalLoginUI_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InPlayerController = InPlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TestBeaconClient.ServerPong
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void ATestBeaconClient::ServerPong()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TestBeaconClient.ServerPong");
|
|
|
|
ATestBeaconClient_ServerPong_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TestBeaconClient.ClientPing
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void ATestBeaconClient::ClientPing()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TestBeaconClient.ClientPing");
|
|
|
|
ATestBeaconClient_ClientPing_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.RegisterTurnBasedMatchInterfaceObject
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTurnBasedBlueprintLibrary::RegisterTurnBasedMatchInterfaceObject(class UObject* WorldContextObject, class APlayerController* PlayerController, class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.RegisterTurnBasedMatchInterfaceObject");
|
|
|
|
UTurnBasedBlueprintLibrary_RegisterTurnBasedMatchInterfaceObject_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetPlayerDisplayName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString PlayerDisplayName (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UTurnBasedBlueprintLibrary::GetPlayerDisplayName(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FString& MatchID, int PlayerIndex, struct FString* PlayerDisplayName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetPlayerDisplayName");
|
|
|
|
UTurnBasedBlueprintLibrary_GetPlayerDisplayName_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchID = MatchID;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PlayerDisplayName != nullptr)
|
|
*PlayerDisplayName = params.PlayerDisplayName;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetMyPlayerIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// int PlayerIndex (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTurnBasedBlueprintLibrary::GetMyPlayerIndex(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FString& MatchID, int* PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetMyPlayerIndex");
|
|
|
|
UTurnBasedBlueprintLibrary_GetMyPlayerIndex_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchID = MatchID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PlayerIndex != nullptr)
|
|
*PlayerIndex = params.PlayerIndex;
|
|
}
|
|
|
|
|
|
// Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetIsMyTurn
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString MatchID (Parm, ZeroConstructor)
|
|
// bool bIsMyTurn (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTurnBasedBlueprintLibrary::GetIsMyTurn(class UObject* WorldContextObject, class APlayerController* PlayerController, const struct FString& MatchID, bool* bIsMyTurn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function OnlineSubsystemUtils.TurnBasedBlueprintLibrary.GetIsMyTurn");
|
|
|
|
UTurnBasedBlueprintLibrary_GetIsMyTurn_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerController = PlayerController;
|
|
params.MatchID = MatchID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (bIsMyTurn != nullptr)
|
|
*bIsMyTurn = params.bIsMyTurn;
|
|
}
|
|
|
|
|
|
}
|
|
|