void APuzzlePresetPlayerController::OnEndTurn()
{
/*UPuzzlePresetGameInstance* ppgi = Cast<UPuzzlePresetGameInstance>(GetGameInstance());
ULocalPlayer* LocalPlayer = GetLocalPlayer();
ppgi->HostSession(MakeShareable(LocalPlayer->GetControllerId()),)
return;*/
IOnlineSubsystem* ion = IOnlineSubsystem::Get(FName("Steam"));
if (ion != nullptr)
{
ULocalPlayer* LocalPlayer = GetLocalPlayer();
if (LocalPlayer && LocalPlayer->GetControllerId() != -1)
{
UE_LOG(LogTemp, Warning, TEXT("steam user name: %s"), *PlayerState->PlayerName);
uint8 status = ion->GetIdentityInterface()->GetLoginStatus(LocalPlayer->GetControllerId());
UE_LOG(LogTemp, Warning, TEXT("steam user status: %d"), status);
}
/*if (ion->InitSteamworksClient(false, 480))
{
UE_LOG(LogTemp, Warning, TEXT("Steam API initialized succesfully!"));
}
else
{
UE_LOG(LogTemp, Warning, TEXT("Failed to initialize Steam API :("));
}*/
}
}
void UUpdateManager::StartPlatformEnvironmentCheck()
{
IOnlineSubsystem* OnlineSubConsole = IOnlineSubsystem::GetByPlatform();
if (!bPlatformEnvironmentDetected &&
OnlineSubConsole != nullptr &&
OnlineSubConsole->GetIdentityInterface().IsValid())
{
SetUpdateState(EUpdateState::DetectingPlatformEnvironment);
ULocalPlayer* LP = GetGameInstance()->GetFirstGamePlayer();
if (LP != nullptr)
{
const int32 ControllerId = LP->GetControllerId();
OnLoginConsoleCompleteHandle = OnlineSubConsole->GetIdentityInterface()->AddOnLoginCompleteDelegate_Handle(
ControllerId,
FOnLoginCompleteDelegate::CreateUObject(this, &ThisClass::PlatformEnvironmentCheck_OnLoginConsoleComplete)
);
OnlineSubConsole->GetIdentityInterface()->Login(ControllerId, FOnlineAccountCredentials());
}
}
else
{
StartHotfixCheck();
}
}
void AFPSGPlayerController::onClickEndGame() const
{
//Make sure it is the server calling the function
if (Role < ROLE_Authority && GetNetMode() == NM_Client) return;
//GEngine->AddOnScreenDebugMessage(-1, 40.0f, FColor::Cyan, "AFPSGPlayerController::onClickEndGame");
IOnlineSubsystem* onlineSubsystem = IOnlineSubsystem::Get();
IOnlineSessionPtr sessions = onlineSubsystem != NULL ? onlineSubsystem->GetSessionInterface() : NULL;
if (sessions.IsValid())
{
UWorld* world = GetWorld();
AFPSGGameState* gameState = world != NULL ? world->GetGameState<AFPSGGameState>() : NULL;
if (gameState != NULL)
{
//Retrieve the session state and match state
EOnlineSessionState::Type sessionState = sessions->GetSessionState(GameSessionName);
FName matchState = gameState->GetMatchState();
//Only attempt to end the game if both the session and match are in progress
if (sessionState == EOnlineSessionState::Type::InProgress && matchState == MatchState::InProgress)
{
gameState->onClickEndGame();
}
}
}
}
/**
* Delegate fired when a session start request has completed
*
* @param SessionName the name of the session this callback is for
* @param bWasSuccessful true if the async action completed without error, false if there was an error
*/
void URadeGameInstance::OnStartOnlineGameComplete(FName SessionName, bool bWasSuccessful)
{
//GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, FString::Printf(TEXT("OnStartSessionComplete %s, %d"), *SessionName.ToString(), bWasSuccessful));
// Get the Online Subsystem so we can get the Session Interface
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
// Get the Session Interface to clear the Delegate
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
// Clear the delegate, since we are done with this call
Sessions->ClearOnStartSessionCompleteDelegate_Handle(OnStartSessionCompleteDelegateHandle);
}
}
// If the start was successful, we can open a NewMap if we want. Make sure to use "listen" as a parameter!
if (bWasSuccessful)
{
//BattleArena
UGameplayStatics::OpenLevel(GetWorld(), *TheMapName, true, "listen");
}
}
// Join Session
bool URadeGameInstance::JoinSession(TSharedPtr<const FUniqueNetId> UserId, FName SessionName, const FOnlineSessionSearchResult& SearchResult)
{
// Return bool
bool bSuccessful = false;
// Get OnlineSubsystem we want to work with
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
// Get SessionInterface from the OnlineSubsystem
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid() && UserId.IsValid())
{
// Set the Handle again
OnJoinSessionCompleteDelegateHandle = Sessions->AddOnJoinSessionCompleteDelegate_Handle(OnJoinSessionCompleteDelegate);
// Call the "JoinSession" Function with the passed "SearchResult". The "SessionSearch->SearchResults" can be used to get such a
// "FOnlineSessionSearchResult" and pass it. Pretty straight forward!
bSuccessful = Sessions->JoinSession(*UserId, SessionName, SearchResult);
}
}
return bSuccessful;
}
/**
* Delegate fired when a session create request has completed
*
* @param SessionName the name of the session this callback is for
* @param bWasSuccessful true if the async action completed without error, false if there was an error
*/
void URadeGameInstance::OnCreateSessionComplete(FName SessionName, bool bWasSuccessful)
{
//GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, FString::Printf(TEXT("OnCreateSessionComplete %s, %d"), *SessionName.ToString(), bWasSuccessful));
// Get the OnlineSubsystem so we can get the Session Interface
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
// Get the Session Interface to call the StartSession function
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
// Clear the SessionComplete delegate handle, since we finished this call
Sessions->ClearOnCreateSessionCompleteDelegate_Handle(OnCreateSessionCompleteDelegateHandle);
if (bWasSuccessful)
{
// Set the StartSession delegate handle
OnStartSessionCompleteDelegateHandle = Sessions->AddOnStartSessionCompleteDelegate_Handle(OnStartSessionCompleteDelegate);
//printr(SessionName.ToString());
// Our StartSessionComplete delegate should get called after this
Sessions->StartSession(SessionName);
}
}
}
}
bool APartyBeaconClient::RequestReservation(const FOnlineSessionSearchResult& DesiredHost, const FUniqueNetIdRepl& RequestingPartyLeader, const TArray<FPlayerReservation>& PartyMembers)
{
bool bSuccess = false;
if (DesiredHost.IsValid())
{
UWorld* World = GetWorld();
IOnlineSubsystem* OnlineSub = Online::GetSubsystem(World);
if (OnlineSub)
{
IOnlineSessionPtr SessionInt = OnlineSub->GetSessionInterface();
if (SessionInt.IsValid())
{
FString ConnectInfo;
if (SessionInt->GetResolvedConnectString(DesiredHost, BeaconPort, ConnectInfo))
{
FString SessionId = DesiredHost.Session.SessionInfo->GetSessionId().ToString();
return RequestReservation(ConnectInfo, SessionId, RequestingPartyLeader, PartyMembers);
}
}
}
}
if (!bSuccess)
{
OnFailure();
}
return bSuccess;
}
/**
* Register all delegates needed to manage online sessions
*/
void UOnlineSessionClient::RegisterOnlineDelegates(UWorld* InWorld)
{
IOnlineSubsystem* OnlineSub = Online::GetSubsystem(InWorld);
if (OnlineSub)
{
SessionInt = OnlineSub->GetSessionInterface();
if (SessionInt.IsValid())
{
int32 ControllerId = GetControllerId();
if (ControllerId != INVALID_CONTROLLERID)
{
// Always on the lookout for invite acceptance (via actual invite or join from external ui)
OnSessionInviteAcceptedDelegate = FOnSessionInviteAcceptedDelegate::CreateUObject(this, &UOnlineSessionClient::OnSessionInviteAccepted);
SessionInt->AddOnSessionInviteAcceptedDelegate(ControllerId, OnSessionInviteAcceptedDelegate);
}
}
OnJoinSessionCompleteDelegate = FOnJoinSessionCompleteDelegate::CreateUObject(this, &UOnlineSessionClient::OnJoinSessionComplete);
OnEndForJoinSessionCompleteDelegate = FOnEndSessionCompleteDelegate::CreateUObject(this, &UOnlineSessionClient::OnEndForJoinSessionComplete);
OnDestroyForJoinSessionCompleteDelegate = FOnDestroySessionCompleteDelegate::CreateUObject(this, &UOnlineSessionClient::OnDestroyForJoinSessionComplete);
}
// Register disconnect delegate even if we don't have an online system
OnDestroyForMainMenuCompleteDelegate = FOnDestroySessionCompleteDelegate::CreateUObject(this, &UOnlineSessionClient::OnDestroyForMainMenuComplete);
}
void URadeGameInstance::OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type Result)
{
// Get the OnlineSubsystem we want to work with
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
// Get SessionInterface from the OnlineSubsystem
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
// Clear the Delegate again
Sessions->ClearOnJoinSessionCompleteDelegate_Handle(OnJoinSessionCompleteDelegateHandle);
// Get the first local PlayerController, so we can call "ClientTravel" to get to the Server Map
// This is something the Blueprint Node "Join Session" does automatically!
APlayerController * const PlayerController = GetFirstLocalPlayerController();
// We need a FString to use ClientTravel and we can let the SessionInterface contruct such a
// String for us by giving him the SessionName and an empty String. We want to do this, because
// Every OnlineSubsystem uses different TravelURLs
FString TravelURL;
if (PlayerController && Sessions->GetResolvedConnectString(SessionName, TravelURL))
{
// Finally call the ClienTravel. If you want, you could print the TravelURL to see
// how it really looks like
PlayerController->ClientTravel(TravelURL, ETravelType::TRAVEL_Absolute);
}
}
}
}
/** Starts the online game using the session name in the PlayerState */
void AShooterPlayerController::ClientStartOnlineGame_Implementation()
{
if (!IsPrimaryPlayer())
return;
AShooterPlayerState* ShooterPlayerState = Cast<AShooterPlayerState>(PlayerState);
if (ShooterPlayerState)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
UE_LOG(LogOnline, Log, TEXT("Starting session %s on client"), *ShooterPlayerState->SessionName.ToString() );
Sessions->StartSession(ShooterPlayerState->SessionName);
}
}
}
else
{
// Keep retrying until player state is replicated
GetWorld()->GetTimerManager().SetTimer(FTimerDelegate::CreateUObject(this, &AShooterPlayerController::ClientStartOnlineGame_Implementation), 0.2f, false);
}
}
IMessageSanitizerPtr FOnlineSubsystemImpl::GetMessageSanitizer(int32 LocalUserNum, FString& OutAuthTypeToExclude) const
{
IMessageSanitizerPtr MessageSanitizer;
IOnlineSubsystem* PlatformSubsystem = IOnlineSubsystem::GetByPlatform();
if (PlatformSubsystem && PlatformSubsystem != static_cast<const IOnlineSubsystem*>(this))
{
MessageSanitizer = PlatformSubsystem->GetMessageSanitizer(LocalUserNum, OutAuthTypeToExclude);
}
return MessageSanitizer;
}
/**
* Serialize the voice packet data to a buffer
*
* @param Ar buffer to write into
*/
void FVoicePacketImpl::Serialize(class FArchive& Ar)
{
// Make sure not to overflow the buffer by reading an invalid amount
if (Ar.IsLoading())
{
FString SenderStr;
Ar << SenderStr;
// Don't need to distinguish OSS interfaces here with world because we just want the create function below
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
IOnlineIdentityPtr IdentityInt = OnlineSub->GetIdentityInterface();
if (IdentityInt.IsValid())
{
Sender = IdentityInt->CreateUniquePlayerId(SenderStr);
}
Ar << Length;
// Verify the packet is a valid size
if (Length <= MAX_VOICE_DATA_SIZE)
{
Buffer.Empty(Length);
Buffer.AddUninitialized(Length);
Ar.Serialize(Buffer.GetData(), Length);
#if DEBUG_VOICE_PACKET_ENCODING
uint32 CRC = 0;
Ar << CRC;
if (CRC != FCrc::MemCrc32(Buffer.GetData(), Length))
{
UE_LOG(LogVoice, Warning, TEXT("CRC Mismatch in voice packet"));
Length = 0;
}
#endif
}
else
{
Length = 0;
}
}
else
{
check(Sender.IsValid());
FString SenderStr = Sender->ToString();
Ar << SenderStr;
Ar << Length;
// Always safe to save the data as the voice code prevents overwrites
Ar.Serialize(Buffer.GetData(), Length);
#if DEBUG_VOICE_PACKET_ENCODING
uint32 CRC = FCrc::MemCrc32(Buffer.GetData(), Length);
Ar << CRC;
#endif
}
}
/** Ends and/or destroys game session */
void AShooterPlayerController::CleanupSessionOnReturnToMenu()
{
bool bPendingOnlineOp = false;
// end online game and then destroy it
AShooterPlayerState* ShooterPlayerState = Cast<AShooterPlayerState>(PlayerState);
if (ShooterPlayerState)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
EOnlineSessionState::Type SessionState = Sessions->GetSessionState(ShooterPlayerState->SessionName);
UE_LOG(LogOnline, Log, TEXT("Session %s is '%s'"), *ShooterPlayerState->SessionName.ToString(), EOnlineSessionState::ToString(SessionState));
if (EOnlineSessionState::InProgress == SessionState)
{
UE_LOG(LogOnline, Log, TEXT("Ending session %s on return to main menu"), *ShooterPlayerState->SessionName.ToString() );
Sessions->AddOnEndSessionCompleteDelegate(OnEndSessionCompleteDelegate);
Sessions->EndSession(ShooterPlayerState->SessionName);
bPendingOnlineOp = true;
}
else if (EOnlineSessionState::Ending == SessionState)
{
UE_LOG(LogOnline, Log, TEXT("Waiting for session %s to end on return to main menu"), *ShooterPlayerState->SessionName.ToString() );
Sessions->AddOnEndSessionCompleteDelegate(OnEndSessionCompleteDelegate);
bPendingOnlineOp = true;
}
else if (EOnlineSessionState::Ended == SessionState ||
EOnlineSessionState::Pending == SessionState)
{
UE_LOG(LogOnline, Log, TEXT("Destroying session %s on return to main menu"), *ShooterPlayerState->SessionName.ToString() );
Sessions->AddOnDestroySessionCompleteDelegate(OnDestroySessionCompleteDelegate);
Sessions->DestroySession(ShooterPlayerState->SessionName);
bPendingOnlineOp = true;
}
else if (EOnlineSessionState::Starting == SessionState)
{
UE_LOG(LogOnline, Log, TEXT("Waiting for session %s to start, and then we will end it to return to main menu"), *ShooterPlayerState->SessionName.ToString() );
Sessions->AddOnStartSessionCompleteDelegate(OnStartSessionCompleteEndItDelegate);
bPendingOnlineOp = true;
}
}
}
}
if (!bPendingOnlineOp)
{
GEngine->HandleDisconnect(GetWorld(), GetWorld()->GetNetDriver());
}
}
void AShooterPlayerController::UpdateAchievementProgress( const FString& Id, float Percent )
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(Player);
if (LocalPlayer)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if(OnlineSub)
{
IOnlineIdentityPtr Identity = OnlineSub->GetIdentityInterface();
if (Identity.IsValid())
{
TSharedPtr<FUniqueNetId> UserId = Identity->GetUniquePlayerId(LocalPlayer->ControllerId);
if (UserId.IsValid())
{
IOnlineAchievementsPtr Achievements = OnlineSub->GetAchievementsInterface();
if (Achievements.IsValid() && (!WriteObject.IsValid() || WriteObject->WriteState != EOnlineAsyncTaskState::InProgress))
{
WriteObject = MakeShareable(new FOnlineAchievementsWrite());
WriteObject->SetFloatStat(*Id, Percent);
FOnlineAchievementsWriteRef WriteObjectRef = WriteObject.ToSharedRef();
Achievements->WriteAchievements(*UserId.Get(), WriteObjectRef);
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No valid achievement interface or another write is in progress."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No valid user id for this controller."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No valid identity interface."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No default online subsystem."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No local player, cannot update achievements."));
}
}
// Destroy Session
void URadeGameInstance::DestroySessionAndLeaveGame()
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
Sessions->AddOnDestroySessionCompleteDelegate_Handle(OnDestroySessionCompleteDelegate);
Sessions->DestroySession(GameSessionName);
}
}
}
void AFPSGPlayerController::onClickQuitToMainMenu()
{
//GEngine->AddOnScreenDebugMessage(-1, 40.0f, FColor::Cyan, "AFPSGPlayerController::onClickQuitToMainMenu");
IOnlineSubsystem* onlineSubsystem = IOnlineSubsystem::Get();
IOnlineSessionPtr sessions = onlineSubsystem != NULL ? onlineSubsystem->GetSessionInterface() : NULL;
if (!sessions.IsValid()) return;
UWorld* world = GetWorld();
AFPSGGameState* gameState = world != NULL ? world->GetGameState<AFPSGGameState>() : NULL;
if (gameState != NULL)
{
//Retrieve the session state and match state
FName matchState = gameState->GetMatchState();
EOnlineSessionState::Type sessionState = EOnlineSessionState::Type::NoSession;
if (Role == ROLE_Authority && GetNetMode() < NM_Client)
{
sessionState = sessions->GetSessionState(GameSessionName);
}
else
{
sessionState = PlayerState != NULL ? sessions->GetSessionState(PlayerState->SessionName) : EOnlineSessionState::Type::NoSession;
}
//Only attempt to end the game if both the session and match are in progress
if (sessionState == EOnlineSessionState::Type::InProgress && matchState == MatchState::InProgress)
{
//Check if it is a server or client that wants to quit to the main menu
if (Role == ROLE_Authority && GetNetMode() < NM_Client)
{
gameState->onClickQuitToMainMenu();
}
else
{
//Client will end and destroy its session locally, and then return to the main menu
clientEndSession();
clientOnlineMatchHasEnded(EEndMatchReason::NONE);
clientDestroySession();
ClientReturnToMainMenu_Implementation("");
}
}
}
}
/**
* Delegate fired when ending an online session has completed
*
* @param SessionName the name of the session this callback is for
* @param bWasSuccessful true if the async action completed without error, false if there was an error
*/
void AShooterPlayerController::OnEndSessionComplete(FName SessionName, bool bWasSuccessful)
{
UE_LOG(LogOnline, Log, TEXT("OnEndSessionComplete: Session=%s bWasSuccessful=%s"), *SessionName.ToString(), bWasSuccessful ? TEXT("true") : TEXT("false") );
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
Sessions->ClearOnEndSessionCompleteDelegate(OnEndSessionCompleteDelegate);
}
}
// continue
CleanupSessionOnReturnToMenu();
}
void AShooterPlayerController::QueryAchievements()
{
// precache achievements
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(Player);
if (LocalPlayer)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if(OnlineSub)
{
IOnlineIdentityPtr Identity = OnlineSub->GetIdentityInterface();
if (Identity.IsValid())
{
TSharedPtr<FUniqueNetId> UserId = Identity->GetUniquePlayerId(LocalPlayer->ControllerId);
if (UserId.IsValid())
{
IOnlineAchievementsPtr Achievements = OnlineSub->GetAchievementsInterface();
if (Achievements.IsValid())
{
Achievements->QueryAchievements( *UserId.Get(), FOnQueryAchievementsCompleteDelegate::CreateUObject( this, &AShooterPlayerController::OnQueryAchievementsComplete ));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No valid user id for this controller."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No valid identity interface."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No default online subsystem."));
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("No local player, cannot read achievements."));
}
}
void FTestCloudInterface::Test()
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get(FName(*Subsystem));
check(OnlineSub);
if (OnlineSub->GetIdentityInterface().IsValid())
{
UserId = OnlineSub->GetIdentityInterface()->GetUniquePlayerId(0);
}
if (UserId.IsValid())
{
// Cache interfaces
UserCloud = OnlineSub->GetUserCloudInterface();
if (UserCloud.IsValid())
{
// Setup delegates
EnumerationDelegate = FOnEnumerateUserFilesCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnEnumerateUserFilesComplete);
OnWriteUserCloudFileCompleteDelegate = FOnWriteUserFileCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnWriteUserCloudFileComplete);
OnReadEnumeratedUserFilesCompleteDelegate = FOnReadUserFileCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnReadEnumeratedUserFilesComplete);
OnDeleteEnumeratedUserFilesCompleteDelegate = FOnDeleteUserFileCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnDeleteEnumeratedUserFilesComplete);
SharedCloud = OnlineSub->GetSharedCloudInterface();
if (SharedCloud.IsValid())
{
OnWriteSharedCloudFileCompleteDelegate = FOnWriteSharedFileCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnWriteSharedCloudFileComplete);
OnReadEnumerateSharedFileCompleteDelegate = FOnReadSharedFileCompleteDelegate::CreateRaw(this, &FTestCloudInterface::OnReadEnumeratedSharedFileCompleteDelegate);
// Pre-generated content
SharedCloud->GetDummySharedHandlesForTest(RandomSharedFileHandles);
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("Cloud test failed. Cloud API not supported."));
delete this;
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("Cloud test failed. No logged in user."));
delete this;
}
}
/**
* Find an online session
*
* @param UserId user that initiated the request
* @param SessionName name of session this search will generate
* @param bIsLAN are we searching LAN matches
* @param bIsPresence are we searching presence sessions
*/
void URadeGameInstance::FindSessions(TSharedPtr<const FUniqueNetId> UserId, FName SessionName, bool bIsLAN, bool bIsPresence)
{
// Get the OnlineSubsystem we want to work with
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
bIsSearchingSession = true;
// Get the SessionInterface from our OnlineSubsystem
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid() && UserId.IsValid())
{
/*
Fill in all the SearchSettings, like if we are searching for a LAN game and how many results we want to have!
*/
SessionSearch = MakeShareable(new FOnlineSessionSearch());
SessionSearch->bIsLanQuery = bIsLAN;
SessionSearch->MaxSearchResults = 20;
SessionSearch->PingBucketSize = 50;
// We only want to set this Query Setting if "bIsPresence" is true
if (bIsPresence)
{
SessionSearch->QuerySettings.Set(SEARCH_PRESENCE, bIsPresence, EOnlineComparisonOp::Equals);
}
TSharedRef<FOnlineSessionSearch> SearchSettingsRef = SessionSearch.ToSharedRef();
// Set the Delegate to the Delegate Handle of the FindSession function
OnFindSessionsCompleteDelegateHandle = Sessions->AddOnFindSessionsCompleteDelegate_Handle(OnFindSessionsCompleteDelegate);
// Finally call the SessionInterface function. The Delegate gets called once this is finished
Sessions->FindSessions(*UserId, SearchSettingsRef);
}
}
else
{
// If something goes wrong, just call the Delegate Function directly with "false".
OnFindSessionsComplete(false);
}
}
void UUModGameInstance::OnStartOnlineGameComplete(FName SessionName, bool bWasSuccessful)
{
GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, FString::Printf(TEXT("OnStartSessionComplete %s, %d"), *SessionName.ToString(), bWasSuccessful));
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
Sessions->ClearOnStartSessionCompleteDelegate_Handle(OnStartSessionCompleteDelegateHandle);
}
}
if (bWasSuccessful)
{
DelayedRunMap = true;
}
}
/** Ends the online game using the session name in the PlayerState */
void AShooterPlayerController::ClientEndOnlineGame_Implementation()
{
if (!IsPrimaryPlayer())
return;
AShooterPlayerState* ShooterPlayerState = Cast<AShooterPlayerState>(PlayerState);
if (ShooterPlayerState)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
UE_LOG(LogOnline, Log, TEXT("Ending session %s on client"), *ShooterPlayerState->SessionName.ToString() );
Sessions->EndSession(ShooterPlayerState->SessionName);
}
}
}
}
void FTestSharingInterface::Test(bool bWithImage)
{
UE_LOG(LogOnline, Verbose, TEXT("FTestSharingInterface::Test"));
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get(FName(*SubsystemName));
check(OnlineSub);
SharingInterface = OnlineSub->GetSharingInterface();
check(SharingInterface.IsValid());
TestStatusUpdate.Message = TEXT("This is a test post for UE4 Facebook support!!");
TestStatusUpdate.PostPrivacy = EOnlineStatusUpdatePrivacy::OnlyMe;
if( bWithImage )
{
TestStatusUpdate.Image = new FImage( 256, 256, ERawImageFormat::BGRA8, false );
}
// Kick off the first part of the test,
RequestPermissionsToSharePosts();
}
void FTestSharingInterface::Test(UWorld* InWorld, bool bWithImage)
{
UE_LOG(LogOnline, Verbose, TEXT("FTestSharingInterface::Test"));
IOnlineSubsystem* OnlineSub = Online::GetSubsystem(InWorld, FName(*SubsystemName));
check(OnlineSub);
SharingInterface = OnlineSub->GetSharingInterface();
check(SharingInterface.IsValid());
TestStatusUpdate.Message = FString::Printf(TEXT("This is a test post for UE4 Sharing support! Date = %s"), *FDateTime::Now().ToString());
TestStatusUpdate.PostPrivacy = EOnlineStatusUpdatePrivacy::OnlyMe;
if( bWithImage )
{
TestStatusUpdate.Image = new FImage( 256, 256, ERawImageFormat::BGRA8, EGammaSpace::Linear );
}
// Kick off the first part of the test,
RequestPermissionsToSharePosts();
}
static void DeleteFromEnumerateUserFilesComplete(bool bWasSuccessful, const FUniqueNetId& UserId)
{
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
check(OnlineSub);
IOnlineUserCloudPtr UserCloud = OnlineSub->GetUserCloudInterface();
UserCloud->ClearOnEnumerateUserFilesCompleteDelegate_Handle(GOnEnumerateUserFilesCompleteDelegateHandle);
GPerCloudDeleteFromEnumerateUserFilesCompleteDelegateHandles.Remove(UserCloud.Get());
if (bWasSuccessful)
{
TArray<FCloudFileHeader> UserFiles;
UserCloud->GetUserFileList(UserId, UserFiles);
for (int32 Idx=0; Idx < UserFiles.Num(); Idx++)
{
UserCloud->DeleteUserFile(UserId, UserFiles[Idx].FileName, true, true);
}
}
}
// Destroy Session And return to Start Map
void URadeGameInstance::OnDestroySessionComplete(FName SessionName, bool bWasSuccessful)
{
// Get the OnlineSubsystem we want to work with
IOnlineSubsystem* OnlineSub = IOnlineSubsystem::Get();
if (OnlineSub)
{
// Get the SessionInterface from the OnlineSubsystem
IOnlineSessionPtr Sessions = OnlineSub->GetSessionInterface();
if (Sessions.IsValid())
{
// Clear the Delegate
Sessions->ClearOnDestroySessionCompleteDelegate_Handle(OnDestroySessionCompleteDelegateHandle);
// If it was successful, we just load another level (could be a MainMenu!)
if (bWasSuccessful)
{
UGameplayStatics::OpenLevel(GetWorld(), "SelectMap", true);
}
}
}
}
bool AFPSGPlayerController::destroySession(FName sessionName) const
{
bool success = false;
IOnlineSubsystem* onlineSubsystem = IOnlineSubsystem::Get();
IOnlineSessionPtr sessions = onlineSubsystem != NULL ? onlineSubsystem->GetSessionInterface() : NULL;
if (sessions.IsValid())
{
//Destroy the session
success = sessions->DestroySession(sessionName);
if (success)
{
GEngine->AddOnScreenDebugMessage(-1, 40.0f, FColor::Cyan, TEXT("AFPSGPlayerController::destroySession success"));
}
else
{
GEngine->AddOnScreenDebugMessage(-1, 40.0f, FColor::Cyan, TEXT("AFPSGPlayerController::destroySession NOT success"));
}
}
return success;
}
bool UQosEvaluator::FindQosServersByRegion(int32 RegionIdx, FOnQosSearchComplete InCompletionDelegate)
{
bool bSuccess = false;
if (Datacenters.IsValidIndex(RegionIdx))
{
FQosRegionInfo& Datacenter = Datacenters[RegionIdx];
Datacenter.Reset();
IOnlineSubsystem* OnlineSub = Online::GetSubsystem(GetWorld());
if (OnlineSub)
{
IOnlineSessionPtr SessionInt = OnlineSub->GetSessionInterface();
if (SessionInt.IsValid())
{
if (!Datacenter.Region.RegionId.IsEmpty())
{
const TSharedRef<FOnlineSessionSearch> QosSearchParams = MakeShareable(new FOnlineSessionSearchQos());
QosSearchParams->QuerySettings.Set(SETTING_REGION, Datacenter.Region.RegionId, EOnlineComparisonOp::Equals);
QosSearchQuery = QosSearchParams;
FOnFindSessionsCompleteDelegate OnFindDatacentersCompleteDelegate = FOnFindSessionsCompleteDelegate::CreateUObject(this, &ThisClass::OnFindQosServersByRegionComplete, RegionIdx, InCompletionDelegate);
OnFindDatacentersCompleteDelegateHandle = SessionInt->AddOnFindSessionsCompleteDelegate_Handle(OnFindDatacentersCompleteDelegate);
SessionInt->FindSessions(ControllerId, QosSearchParams);
}
else
{
OnFindQosServersByRegionComplete(false, RegionIdx, InCompletionDelegate);
}
bSuccess = true;
}
}
}
return bSuccess;
}
void FTestEntitlementsInterface::Test(UWorld* InWorld)
{
IOnlineSubsystem* OSS = Online::GetSubsystem(InWorld, SubsystemName.Len() ? FName(*SubsystemName, FNAME_Find) : NAME_None);
IdentityOSS = OSS->GetIdentityInterface();
if (IdentityOSS.IsValid())
{
UserId = IdentityOSS->GetUniquePlayerId(LocalUserIdx);
}
if (UserId.IsValid() && UserId->IsValid())
{
EntitlementsOSS = OSS->GetEntitlementsInterface();
if (EntitlementsOSS.IsValid())
{
// Add delegates for the various async calls
OnQueryEntitlementsCompleteDelegateHandle = EntitlementsOSS->AddOnQueryEntitlementsCompleteDelegate_Handle(OnQueryEntitlementsCompleteDelegate);
// kick off next test
StartNextTest();
}
else
{
UE_LOG(LogOnline, Warning, TEXT("Entitlement test failed. Failed to get entitlement service API"));
// done with the test
FinishTest();
}
}
else
{
UE_LOG(LogOnline, Warning, TEXT("Entitlement test failed. No logged in user"));
// done with the test
FinishTest();
}
}
UOnlineHotfixManager* UOnlineHotfixManager::Get(UWorld* World)
{
UOnlineHotfixManager* DefaultObject = UOnlineHotfixManager::StaticClass()->GetDefaultObject<UOnlineHotfixManager>();
IOnlineSubsystem* OnlineSub = Online::GetSubsystem(World, DefaultObject->OSSName.Len() > 0 ? FName(*DefaultObject->OSSName) : NAME_None);
if (OnlineSub != nullptr)
{
UOnlineHotfixManager* HotfixManager = Cast<UOnlineHotfixManager>(OnlineSub->GetNamedInterface(NAME_HotfixManager));
if (HotfixManager == nullptr)
{
FString HotfixManagerClassName = DefaultObject->HotfixManagerClassName;
UClass* HotfixManagerClass = LoadClass<UOnlineHotfixManager>(nullptr, *HotfixManagerClassName, nullptr, LOAD_None, nullptr);
if (HotfixManagerClass == nullptr)
{
// Just use the default class if it couldn't load what was specified
HotfixManagerClass = UOnlineHotfixManager::StaticClass();
}
// Create it and store it
HotfixManager = NewObject<UOnlineHotfixManager>(GetTransientPackage(), HotfixManagerClass);
OnlineSub->SetNamedInterface(NAME_HotfixManager, HotfixManager);
}
return HotfixManager;
}
return nullptr;
}
