mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-29 02:47:17 +09:00
1291 lines
41 KiB
C++
1291 lines
41 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// FUNCTIONS
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Class PocketpairUser.HTTPRequestAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UHTTPRequestAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("HTTPRequestAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// HTTPRequestAsyncFunction PocketpairUser.Default__HTTPRequestAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UHTTPRequestAsyncFunction* UHTTPRequestAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UHTTPRequestAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UHTTPRequestAsyncFunction*>(UHTTPRequestAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.HTTPRequestAsyncFunction.HTTPRequestAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString URL (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Verb (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UHTTPRequestAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UHTTPRequestAsyncFunction* UHTTPRequestAsyncFunction::HTTPRequestAsyncFunction(class UPocketpairUserSubsystem* Target, const class FString& URL, const class FString& Verb)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("HTTPRequestAsyncFunction", "HTTPRequestAsyncFunction");
|
|
|
|
Params::UHTTPRequestAsyncFunction_HTTPRequestAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.URL = URL;
|
|
Parms.Verb = Verb;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.SwitchUserUIDefaultOnlineSubsystemAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* USwitchUserUIDefaultOnlineSubsystemAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SwitchUserUIDefaultOnlineSubsystemAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SwitchUserUIDefaultOnlineSubsystemAsyncFunction PocketpairUser.Default__SwitchUserUIDefaultOnlineSubsystemAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USwitchUserUIDefaultOnlineSubsystemAsyncFunction* USwitchUserUIDefaultOnlineSubsystemAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class USwitchUserUIDefaultOnlineSubsystemAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USwitchUserUIDefaultOnlineSubsystemAsyncFunction*>(USwitchUserUIDefaultOnlineSubsystemAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.SwitchUserUIDefaultOnlineSubsystemAsyncFunction.SwitchUserUIAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USwitchUserUIDefaultOnlineSubsystemAsyncFunction*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class USwitchUserUIDefaultOnlineSubsystemAsyncFunction* USwitchUserUIDefaultOnlineSubsystemAsyncFunction::SwitchUserUIAsyncFunction(class UPocketpairUserSubsystem* Target)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SwitchUserUIDefaultOnlineSubsystemAsyncFunction", "SwitchUserUIAsyncFunction");
|
|
|
|
Params::USwitchUserUIDefaultOnlineSubsystemAsyncFunction_SwitchUserUIAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.LoginDefaultOnlineSubsystemAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* ULoginDefaultOnlineSubsystemAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LoginDefaultOnlineSubsystemAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LoginDefaultOnlineSubsystemAsyncFunction PocketpairUser.Default__LoginDefaultOnlineSubsystemAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULoginDefaultOnlineSubsystemAsyncFunction* ULoginDefaultOnlineSubsystemAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class ULoginDefaultOnlineSubsystemAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULoginDefaultOnlineSubsystemAsyncFunction*>(ULoginDefaultOnlineSubsystemAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.LoginDefaultOnlineSubsystemAsyncFunction.LoginDefaultAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULoginDefaultOnlineSubsystemAsyncFunction*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULoginDefaultOnlineSubsystemAsyncFunction* ULoginDefaultOnlineSubsystemAsyncFunction::LoginDefaultAsyncFunction(class UPocketpairUserSubsystem* Target)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LoginDefaultOnlineSubsystemAsyncFunction", "LoginDefaultAsyncFunction");
|
|
|
|
Params::ULoginDefaultOnlineSubsystemAsyncFunction_LoginDefaultAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.LoginEOSAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* ULoginEOSAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LoginEOSAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LoginEOSAsyncFunction PocketpairUser.Default__LoginEOSAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULoginEOSAsyncFunction* ULoginEOSAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class ULoginEOSAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULoginEOSAsyncFunction*>(ULoginEOSAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.LoginEOSAsyncFunction.LoginEOSAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class ULoginEOSAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class ULoginEOSAsyncFunction* ULoginEOSAsyncFunction::LoginEOSAsyncFunction(class UPocketpairUserSubsystem* Target)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LoginEOSAsyncFunction", "LoginEOSAsyncFunction");
|
|
|
|
Params::ULoginEOSAsyncFunction_LoginEOSAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.CreateSessionAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UCreateSessionAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("CreateSessionAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// CreateSessionAsyncFunction PocketpairUser.Default__CreateSessionAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UCreateSessionAsyncFunction* UCreateSessionAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UCreateSessionAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UCreateSessionAsyncFunction*>(UCreateSessionAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.CreateSessionAsyncFunction.CreateSessionAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool IsDedicatedServer (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 PublicConnections (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString InviteCode (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ServerName (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Desc (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ServerAddress (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ServerPort (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool IsPassword (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Version (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ServerType (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Region (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Namespace (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCreateSessionAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UCreateSessionAsyncFunction* UCreateSessionAsyncFunction::CreateSessionAsyncFunction(class UPocketpairUserSubsystem* Target, bool IsDedicatedServer, int32 PublicConnections, const class FString& InviteCode, const class FString& ServerName, const class FString& Desc, const class FString& ServerAddress, int32 ServerPort, bool IsPassword, const class FString& Version, const class FString& ServerType, const class FString& Region, const class FString& Namespace)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("CreateSessionAsyncFunction", "CreateSessionAsyncFunction");
|
|
|
|
Params::UCreateSessionAsyncFunction_CreateSessionAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.IsDedicatedServer = IsDedicatedServer;
|
|
Parms.PublicConnections = PublicConnections;
|
|
Parms.InviteCode = InviteCode;
|
|
Parms.ServerName = ServerName;
|
|
Parms.Desc = Desc;
|
|
Parms.ServerAddress = ServerAddress;
|
|
Parms.ServerPort = ServerPort;
|
|
Parms.IsPassword = IsPassword;
|
|
Parms.Version = Version;
|
|
Parms.ServerType = ServerType;
|
|
Parms.Region = Region;
|
|
Parms.Namespace = Namespace;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.FindSessionsAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UFindSessionsAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("FindSessionsAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// FindSessionsAsyncFunction PocketpairUser.Default__FindSessionsAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UFindSessionsAsyncFunction* UFindSessionsAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UFindSessionsAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UFindSessionsAsyncFunction*>(UFindSessionsAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.FindSessionsAsyncFunction.FindSessionsAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool IsDedicatedServer (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString InviteCode (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ServerType (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Region (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 LessThanTime (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString WorldGUID (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString Namespace (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UFindSessionsAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UFindSessionsAsyncFunction* UFindSessionsAsyncFunction::FindSessionsAsyncFunction(class UPocketpairUserSubsystem* Target, bool IsDedicatedServer, const class FString& InviteCode, const class FString& ServerType, const class FString& Region, int32 LessThanTime, const class FString& WorldGUID, const class FString& Namespace)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("FindSessionsAsyncFunction", "FindSessionsAsyncFunction");
|
|
|
|
Params::UFindSessionsAsyncFunction_FindSessionsAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.IsDedicatedServer = IsDedicatedServer;
|
|
Parms.InviteCode = InviteCode;
|
|
Parms.ServerType = ServerType;
|
|
Parms.Region = Region;
|
|
Parms.LessThanTime = LessThanTime;
|
|
Parms.WorldGUID = WorldGUID;
|
|
Parms.Namespace = Namespace;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.JoinSessionAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UJoinSessionAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("JoinSessionAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// JoinSessionAsyncFunction PocketpairUser.Default__JoinSessionAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UJoinSessionAsyncFunction* UJoinSessionAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UJoinSessionAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UJoinSessionAsyncFunction*>(UJoinSessionAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.SanitizeDisplayNameAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* USanitizeDisplayNameAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SanitizeDisplayNameAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SanitizeDisplayNameAsyncFunction PocketpairUser.Default__SanitizeDisplayNameAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USanitizeDisplayNameAsyncFunction* USanitizeDisplayNameAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class USanitizeDisplayNameAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USanitizeDisplayNameAsyncFunction*>(USanitizeDisplayNameAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.SanitizeDisplayNameAsyncFunction.SanitizeDisplayNameAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString InString (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USanitizeDisplayNameAsyncFunction*ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class USanitizeDisplayNameAsyncFunction* USanitizeDisplayNameAsyncFunction::SanitizeDisplayNameAsyncFunction(class UPocketpairUserSubsystem* Target, const class FString& InString)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SanitizeDisplayNameAsyncFunction", "SanitizeDisplayNameAsyncFunction");
|
|
|
|
Params::USanitizeDisplayNameAsyncFunction_SanitizeDisplayNameAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.InString = InString;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.PingIP
|
|
// (None)
|
|
|
|
class UClass* UPingIP::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("PingIP");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// PingIP PocketpairUser.Default__PingIP
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UPingIP* UPingIP::GetDefaultObj()
|
|
{
|
|
static class UPingIP* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UPingIP*>(UPingIP::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PingIP.SendPing
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString IpAddress (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPingIP::SendPing(const class FString& IpAddress)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PingIP", "SendPing");
|
|
|
|
Params::UPingIP_SendPing_Params Parms{};
|
|
|
|
Parms.IpAddress = IpAddress;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PingIP.PollThread
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void UPingIP::PollThread()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PingIP", "PollThread");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PingIP.ConstructPingObject
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPingIP* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UPingIP* UPingIP::ConstructPingObject()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PingIP", "ConstructPingObject");
|
|
|
|
Params::UPingIP_ConstructPingObject_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.PocketpairUserInfo
|
|
// (None)
|
|
|
|
class UClass* UPocketpairUserInfo::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("PocketpairUserInfo");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// PocketpairUserInfo PocketpairUser.Default__PocketpairUserInfo
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UPocketpairUserInfo* UPocketpairUserInfo::GetDefaultObj()
|
|
{
|
|
static class UPocketpairUserInfo* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UPocketpairUserInfo*>(UPocketpairUserInfo::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserInfo.GetOnlineSubsystemName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FName UPocketpairUserInfo::GetOnlineSubsystemName()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserInfo", "GetOnlineSubsystemName");
|
|
|
|
Params::UPocketpairUserInfo_GetOnlineSubsystemName_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserInfo.GetNickname
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserInfo::GetNickname()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserInfo", "GetNickname");
|
|
|
|
Params::UPocketpairUserInfo_GetNickname_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserInfo.GetNetId
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl ReturnValue (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FUniqueNetIdRepl UPocketpairUserInfo::GetNetId()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserInfo", "GetNetId");
|
|
|
|
Params::UPocketpairUserInfo_GetNetId_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserInfo.GetDebugString
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserInfo::GetDebugString()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserInfo", "GetDebugString");
|
|
|
|
Params::UPocketpairUserInfo_GetDebugString_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.PocketpairFriend
|
|
// (None)
|
|
|
|
class UClass* UPocketpairFriend::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("PocketpairFriend");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// PocketpairFriend PocketpairUser.Default__PocketpairFriend
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UPocketpairFriend* UPocketpairFriend::GetDefaultObj()
|
|
{
|
|
static class UPocketpairFriend* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UPocketpairFriend*>(UPocketpairFriend::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairFriend.GetNetId
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl ReturnValue (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FUniqueNetIdRepl UPocketpairFriend::GetNetId()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairFriend", "GetNetId");
|
|
|
|
Params::UPocketpairFriend_GetNetId_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.PocketpairUserSubsystem
|
|
// (None)
|
|
|
|
class UClass* UPocketpairUserSubsystem::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("PocketpairUserSubsystem");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// PocketpairUserSubsystem PocketpairUser.Default__PocketpairUserSubsystem
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UPocketpairUserSubsystem* UPocketpairUserSubsystem::GetDefaultObj()
|
|
{
|
|
static class UPocketpairUserSubsystem* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UPocketpairUserSubsystem*>(UPocketpairUserSubsystem::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.UnlockAchievement
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString ID (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Percent (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPocketpairUserSubsystem::UnlockAchievement(const class FString& ID, float Percent)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "UnlockAchievement");
|
|
|
|
Params::UPocketpairUserSubsystem_UnlockAchievement_Params Parms{};
|
|
|
|
Parms.ID = ID;
|
|
Parms.Percent = Percent;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.OnSessionInviteReceived
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class FString InviteCode (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPocketpairUserSubsystem::OnSessionInviteReceived(const class FString& InviteCode)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "OnSessionInviteReceived");
|
|
|
|
Params::UPocketpairUserSubsystem_OnSessionInviteReceived_Params Parms{};
|
|
|
|
Parms.InviteCode = InviteCode;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetTelemetryUserId
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserSubsystem::GetTelemetryUserId()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetTelemetryUserId");
|
|
|
|
Params::UPocketpairUserSubsystem_GetTelemetryUserId_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetTelemetrySessionId
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserSubsystem::GetTelemetrySessionId()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetTelemetrySessionId");
|
|
|
|
Params::UPocketpairUserSubsystem_GetTelemetrySessionId_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetSocialId
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSocialId ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FSocialId UPocketpairUserSubsystem::GetSocialId(class APlayerController* PlayerController)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetSocialId");
|
|
|
|
Params::UPocketpairUserSubsystem_GetSocialId_Params Parms{};
|
|
|
|
Parms.PlayerController = PlayerController;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetSaveDataUserId
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserSubsystem::GetSaveDataUserId()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetSaveDataUserId");
|
|
|
|
Params::UPocketpairUserSubsystem_GetSaveDataUserId_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetPlayerNo
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UPocketpairUserSubsystem::GetPlayerNo(class APlayerController* PlayerController)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetPlayerNo");
|
|
|
|
Params::UPocketpairUserSubsystem_GetPlayerNo_Params Parms{};
|
|
|
|
Parms.PlayerController = PlayerController;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetPingResultCache
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString Address (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 UPocketpairUserSubsystem::GetPingResultCache(const class FString& Address)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetPingResultCache");
|
|
|
|
Params::UPocketpairUserSubsystem_GetPingResultCache_Params Parms{};
|
|
|
|
Parms.Address = Address;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetLocalUserInfo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPocketpairUserInfo* ReturnValue (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UPocketpairUserInfo* UPocketpairUserSubsystem::GetLocalUserInfo()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetLocalUserInfo");
|
|
|
|
Params::UPocketpairUserSubsystem_GetLocalUserInfo_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetInviteCode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FString UPocketpairUserSubsystem::GetInviteCode()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetInviteCode");
|
|
|
|
Params::UPocketpairUserSubsystem_GetInviteCode_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.GetDefaultOnlineSubsystemName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FName UPocketpairUserSubsystem::GetDefaultOnlineSubsystemName()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "GetDefaultOnlineSubsystemName");
|
|
|
|
Params::UPocketpairUserSubsystem_GetDefaultOnlineSubsystemName_Params Parms{};
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.PocketpairUserSubsystem.AddPingResultCache
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class FString Address (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Ping (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPocketpairUserSubsystem::AddPingResultCache(const class FString& Address, int32 Ping)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PocketpairUserSubsystem", "AddPingResultCache");
|
|
|
|
Params::UPocketpairUserSubsystem_AddPingResultCache_Params Parms{};
|
|
|
|
Parms.Address = Address;
|
|
Parms.Ping = Ping;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.GDKActivityAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UGDKActivityAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("GDKActivityAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// GDKActivityAsyncFunction PocketpairUser.Default__GDKActivityAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UGDKActivityAsyncFunction* UGDKActivityAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UGDKActivityAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UGDKActivityAsyncFunction*>(UGDKActivityAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.GDKActivityAsyncFunction.GDKActivityAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString ConnectionString (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 MaxPlayerNum (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 CurrentPlayerNum (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UGDKActivityAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UGDKActivityAsyncFunction* UGDKActivityAsyncFunction::GDKActivityAsyncFunction(class UPocketpairUserSubsystem* Target, const class FString& ConnectionString, int32 MaxPlayerNum, int32 CurrentPlayerNum)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("GDKActivityAsyncFunction", "GDKActivityAsyncFunction");
|
|
|
|
Params::UGDKActivityAsyncFunction_GDKActivityAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
Parms.ConnectionString = ConnectionString;
|
|
Parms.MaxPlayerNum = MaxPlayerNum;
|
|
Parms.CurrentPlayerNum = CurrentPlayerNum;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class PocketpairUser.GDKInviteAsyncFunction
|
|
// (None)
|
|
|
|
class UClass* UGDKInviteAsyncFunction::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("GDKInviteAsyncFunction");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// GDKInviteAsyncFunction PocketpairUser.Default__GDKInviteAsyncFunction
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UGDKInviteAsyncFunction* UGDKInviteAsyncFunction::GetDefaultObj()
|
|
{
|
|
static class UGDKInviteAsyncFunction* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UGDKInviteAsyncFunction*>(UGDKInviteAsyncFunction::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function PocketpairUser.GDKInviteAsyncFunction.GDKInviteAsyncFunction
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPocketpairUserSubsystem* Target (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UGDKInviteAsyncFunction* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UGDKInviteAsyncFunction* UGDKInviteAsyncFunction::GDKInviteAsyncFunction(class UPocketpairUserSubsystem* Target)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("GDKInviteAsyncFunction", "GDKInviteAsyncFunction");
|
|
|
|
Params::UGDKInviteAsyncFunction_GDKInviteAsyncFunction_Params Parms{};
|
|
|
|
Parms.Target = Target;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|