bool FOnlineIdentitySteam::AutoLogin(int32 LocalUserNum)
{
if (!IsRunningDedicatedServer())
{
// Double check they are properly logged in
if (SteamUserPtr != NULL &&
// Login is handled by steam
SteamUserPtr->BLoggedOn())
{
// Login changed delegate
TriggerOnLoginChangedDelegates(LocalUserNum);
// Login completion delegate
FString AuthToken = GetAuthToken(LocalUserNum);
TriggerOnLoginCompleteDelegates(LocalUserNum, true, FUniqueNetIdSteam(SteamUserPtr->GetSteamID()), TEXT(""));
return true;
}
TriggerOnLoginCompleteDelegates(0, false, FUniqueNetIdSteam(0), TEXT("AutoLogin failed. Not logged in or no connection."));
return false;
}
else
{
// Autologin for dedicated servers happens via session creation in the GameServerAPI LogOnAnonymous()
return false;
}
}
EOnlineCachedResult::Type FOnlineAchievementsSteam::GetCachedAchievement(const FUniqueNetId& PlayerId, const FString& AchievementId, FOnlineAchievement& OutAchievement)
{
if (!bHaveConfiguredAchievements)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been configured in .ini"));
return EOnlineCachedResult::NotFound;
}
const TArray<FOnlineAchievement> * PlayerAch = PlayerAchievements.Find(FUniqueNetIdSteam (PlayerId));
if (NULL == PlayerAch)
{
// achievements haven't been read for a player
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been read for player %s"), *PlayerId.ToString());
return EOnlineCachedResult::NotFound;
}
const int32 AchNum = PlayerAch->Num();
for (int32 AchIdx = 0; AchIdx < AchNum; ++AchIdx)
{
if ((*PlayerAch)[ AchIdx ].Id == AchievementId)
{
OutAchievement = (*PlayerAch)[ AchIdx ];
return EOnlineCachedResult::Success;
}
}
// no such achievement
UE_LOG_ONLINE(Warning, TEXT("Could not find Steam achievement '%s' for player %s"), *AchievementId, *PlayerId.ToString());
return EOnlineCachedResult::NotFound;
};
void FOnlineAchievementsSteam::QueryAchievementDescriptions( const FUniqueNetId& PlayerId, const FOnQueryAchievementsCompleteDelegate& Delegate )
{
if (!bHaveConfiguredAchievements)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been configured in .ini"));
Delegate.ExecuteIfBound( PlayerId, false );
return;
}
// schedule a read (this will trigger the OnAchievementDescriptionsRead delegates)
StatsInt->QueryAchievementsInternal( FUniqueNetIdSteam(PlayerId), Delegate );
}
bool FOnlineAchievementsSteam::ReadAchievementDescriptions(const FUniqueNetId& PlayerId)
{
if (!bHaveConfiguredAchievements)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been configured in .ini"));
TriggerOnAchievementDescriptionsReadDelegates(PlayerId, false);
return false;
}
// schedule a read (this will trigger the OnAchievementDescriptionsRead delegates)
StatsInt->ReadAchievements(FUniqueNetIdSteam(PlayerId), true);
return true;
};
bool FOnlineIdentitySteam::Login(int32 LocalUserNum, const FOnlineAccountCredentials& AccountCredentials)
{
FString ErrorStr;
if (LocalUserNum < MAX_LOCAL_PLAYERS)
{
// Double check they are properly logged in
if (SteamUserPtr != NULL &&
// Login is handled by steam
SteamUserPtr->BLoggedOn())
{
// Login changed delegate
TriggerOnLoginChangedDelegates(LocalUserNum);
// Login completion delegate
TriggerOnLoginCompleteDelegates(LocalUserNum, true, FUniqueNetIdSteam(SteamUserPtr->GetSteamID()), TEXT(""));
return true;
}
else
{
// User is not currently logged into Steam
ErrorStr = TEXT("Not logged in or no connection.");
}
}
else
{
// Requesting a local user is always invalid
ErrorStr = FString::Printf(TEXT("Invalid user %d"),LocalUserNum);
}
if (!ErrorStr.IsEmpty())
{
UE_LOG_ONLINE(Warning, TEXT("Failed Steam login. %s"), *ErrorStr);
TriggerOnLoginCompleteDelegates(LocalUserNum, false, FUniqueNetIdSteam(0), ErrorStr);
}
return false;
}
EOnlineCachedResult::Type FOnlineAchievementsSteam::GetCachedAchievements(const FUniqueNetId& PlayerId, TArray<FOnlineAchievement> & OutAchievements)
{
if (!bHaveConfiguredAchievements)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been configured in .ini"));
return EOnlineCachedResult::NotFound;
}
const TArray<FOnlineAchievement> * PlayerAch = PlayerAchievements.Find(FUniqueNetIdSteam (PlayerId));
if (NULL == PlayerAch)
{
// achievements haven't been read for a player
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been read for player %s"), *PlayerId.ToString());
return EOnlineCachedResult::NotFound;
}
OutAchievements = *PlayerAch;
return EOnlineCachedResult::Success;
};
/**
* Create a search result from a server response
*
* @param ServerDetails Steam server details
*/
void FOnlineAsyncTaskSteamFindServerBase::ParseSearchResult(class gameserveritem_t* ServerDetails)
{
TSharedRef<FInternetAddr> ServerAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
ServerAddr->SetIp(ServerDetails->m_NetAdr.GetIP());
ServerAddr->SetPort(ServerDetails->m_NetAdr.GetConnectionPort());
int32 ServerQueryPort = ServerDetails->m_NetAdr.GetQueryPort();
UE_LOG_ONLINE(Warning, TEXT("Server response IP:%s"), *ServerAddr->ToString(false));
if (ServerDetails->m_bHadSuccessfulResponse)
{
FString GameTags(UTF8_TO_TCHAR(ServerDetails->m_szGameTags));
// Check for build compatibility
int32 ServerBuildId = 0;
int32 BuildUniqueId = GetBuildUniqueId();
TArray<FString> TagArray;
GameTags.ParseIntoArray(TagArray, TEXT(","), true);
if (TagArray.Num() > 0 && TagArray[0].StartsWith(STEAMKEY_BUILDUNIQUEID))
{
ServerBuildId = FCString::Atoi(*TagArray[0].Mid(ARRAY_COUNT(STEAMKEY_BUILDUNIQUEID)));
}
if (ServerBuildId != 0 && ServerBuildId == BuildUniqueId)
{
// Create a new pending search result
FPendingSearchResultSteam* NewPendingSearch = new (PendingSearchResults) FPendingSearchResultSteam(this);
NewPendingSearch->ServerId = FUniqueNetIdSteam(ServerDetails->m_steamID);
NewPendingSearch->HostAddr = ServerAddr;
// Fill search result members
FOnlineSessionSearchResult* NewSearchResult = &NewPendingSearch->PendingSearchResult;
NewSearchResult->PingInMs = FMath::Clamp(ServerDetails->m_nPing, 0, MAX_QUERY_PING);
// Fill session members
FOnlineSession* NewSession = &NewSearchResult->Session;
//NewSession->OwningUserId = ;
NewSession->OwningUserName = UTF8_TO_TCHAR(ServerDetails->GetName());
NewSession->NumOpenPublicConnections = ServerDetails->m_nMaxPlayers - ServerDetails->m_nPlayers;
NewSession->NumOpenPrivateConnections = 0;
// Fill session settings members
NewSession->SessionSettings.NumPublicConnections = ServerDetails->m_nMaxPlayers;
NewSession->SessionSettings.NumPrivateConnections = 0;
NewSession->SessionSettings.bAntiCheatProtected = ServerDetails->m_bSecure ? true : false;
NewSession->SessionSettings.Set(SETTING_MAPNAME, FString(UTF8_TO_TCHAR(ServerDetails->m_szMap)), EOnlineDataAdvertisementType::ViaOnlineService);
// Start a rules request for this new result
NewPendingSearch->ServerQueryHandle = SteamMatchmakingServersPtr->ServerRules(ServerDetails->m_NetAdr.GetIP(), ServerQueryPort, NewPendingSearch);
if (NewPendingSearch->ServerQueryHandle == HSERVERQUERY_INVALID)
{
// Remove the failed element
PendingSearchResults.RemoveAtSwap(PendingSearchResults.Num() - 1);
}
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Removed incompatible build: ServerBuildUniqueId = 0x%08x, GetBuildUniqueId() = 0x%08x"),
ServerBuildId, BuildUniqueId);
}
}
}
bool FOnlineSharedCloudSteam::WriteSharedFile(const FUniqueNetId& UserId, const FString& FileName, TArray<uint8>& FileContents)
{
SteamSubsystem->QueueAsyncTask(new FOnlineAsyncTaskSteamWriteSharedFile(SteamSubsystem, FUniqueNetIdSteam(*(uint64*)UserId.GetBytes()), FileName, FileContents));
return true;
}
bool FOnlineUserCloudSteam::DeleteUserFile(const FUniqueNetId& UserId, const FString& FileName, bool bShouldCloudDelete, bool bShouldLocallyDelete)
{
SteamSubsystem->QueueAsyncTask(new FOnlineAsyncTaskSteamDeleteUserFile(SteamSubsystem, FUniqueNetIdSteam(*(uint64*)UserId.GetBytes()), FileName, bShouldCloudDelete, bShouldLocallyDelete));
return true;
}
bool FOnlineUserCloudSteam::WriteUserFile(const FUniqueNetId& UserId, const FString& FileName, TArray<uint8>& FileContents)
{
FScopeLock(&SteamSubsystem->UserCloudDataLock);
// Create or get the current entry for this file
FSteamUserCloudData* UserCloud = SteamSubsystem->GetUserCloudEntry(UserId);
if (UserCloud && FileName.Len() > 0)
{
FCloudFile* UserCloudFile = UserCloud->GetFileData(FileName, true);
UserCloudFile->AsyncState = EOnlineAsyncTaskState::InProgress;
SteamSubsystem->QueueAsyncTask(new FOnlineAsyncTaskSteamWriteUserFile(SteamSubsystem, FUniqueNetIdSteam(*(uint64*)UserId.GetBytes()), FileName, FileContents));
return true;
}
return false;
}
void FOnlineUserCloudSteam::EnumerateUserFiles(const FUniqueNetId& UserId)
{
SteamSubsystem->QueueAsyncTask(new FOnlineAsyncTaskSteamEnumerateUserFiles(SteamSubsystem, FUniqueNetIdSteam(*(uint64*)UserId.GetBytes())));
}
