// Returns current app steam userdata path ( something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local" )
String Steam::get_userdata_path()
{
if ( SteamUser() == NULL ) { return ""; }
const int cubBuffer = 256; // unsure if it represents char* size in SteamAPI
const char *pchBuffer = new const char[cubBuffer];
bool error = SteamUser()->GetUserDataFolder( (char*)pchBuffer, cubBuffer );
// ?error? handling?
return pchBuffer;
}
//-----------------------------------------------------------------------------
// Purpose: Tell steam that we are leaving a server
//-----------------------------------------------------------------------------
void CSteam3Client::TerminateConnection( uint32 unIP, uint16 usPort )
{
m_bGSSecure = false;
#if !defined( NO_STEAM )
if ( !SteamUser() )
return;
SteamUser()->TerminateGameConnection( ntohl( unIP ), usPort );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSteam3Client::OnPersonaUpdated( PersonaStateChange_t *pPersonaStateChanged )
{
if ( pPersonaStateChanged->m_nChangeFlags & k_EPersonaChangeName )
{
if ( SteamUtils() && SteamFriends() && SteamUser() )
{
CSteamID steamID = SteamUser()->GetSteamID();
IConVar *pConVar = g_pCVar->FindVar( "name" );
UpdateNameFromSteamID( pConVar, &steamID );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Get the steam3 logon cookie to use
//-----------------------------------------------------------------------------
int CSteam3Client::InitiateConnection( void *pData, int cbMaxData, uint32 unIP, uint16 usPort, uint64 unGSSteamID, bool bSecure, void *pvSteam2GetEncryptionKey, int cbSteam2GetEncryptionKey )
{
m_bGSSecure = bSecure;
#if !defined( NO_STEAM )
if ( !SteamUser() )
return 0;
return SteamUser()->InitiateGameConnection( pData, cbMaxData, unGSSteamID, CGameID( g_iSteamAppID ), ntohl( unIP ), usPort, bSecure, pvSteam2GetEncryptionKey, cbSteam2GetEncryptionKey ); // port is already in host order
#else
return 0;
#endif
}
// Set data to be replicated to friends so that they can join your game
void Steam::user_set_server_info(Ref<SteamID> gameserver, const String& server_ip, int port)
{
if ( SteamUser() == NULL ) { return; }
// resolve address and convert it to int (IP_Address) union
IP_Address addr(IP::get_singleton()->resolve_hostname(server_ip));
// for some reason bytes are in wrong order, need to swap them
for(int i=0;i<2;i++)
{
uint8 temp = addr.field[i];
addr.field[i] = addr.field[3-i];
addr.field[3-i] = temp;
}
// printf("IP int: %ld",addr.host);
SteamUser()->AdvertiseGame(gameserver->getCSteamID(), addr.host, port);
}
bool CSteamAchievements::RequestStats()
{
// Is Steam loaded? If not we can't get stats.
if ( NULL == SteamUserStats() || NULL == SteamUser() )
{
return false;
}
// Is the user logged on? If not we can't get stats.
if ( !SteamUser()->BLoggedOn() )
{
return false;
}
// Request user stats.
return SteamUserStats()->RequestCurrentStats();
}
FOnlineIdentitySteam::FOnlineIdentitySteam() :
SteamUserPtr(NULL),
SteamFriendsPtr(NULL)
{
SteamUserPtr = SteamUser();
SteamFriendsPtr = SteamFriends();
}
bool FOnlineSubsystemSteam::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
{
if (FOnlineSubsystemImpl::Exec(InWorld, Cmd, Ar))
{
return true;
}
bool bWasHandled = false;
if (FParse::Command(&Cmd, TEXT("DELETECLOUDFILES")))
{
IOnlineUserCloudPtr UserCloud = GetUserCloudInterface();
FUniqueNetIdSteam SteamId(SteamUser()->GetSteamID());
FOnEnumerateUserFilesCompleteDelegate Delegate = FOnEnumerateUserFilesCompleteDelegate::CreateStatic(&DeleteFromEnumerateUserFilesComplete);
GPerCloudDeleteFromEnumerateUserFilesCompleteDelegateHandles.Add(UserCloud.Get(), UserCloud->AddOnEnumerateUserFilesCompleteDelegate_Handle(Delegate));
UserCloud->EnumerateUserFiles(SteamId);
bWasHandled = true;
}
else if (FParse::Command(&Cmd, TEXT("SYNCLOBBIES")))
{
if (SessionInterface.IsValid())
{
SessionInterface->SyncLobbies();
bWasHandled = true;
}
}
return bWasHandled;
}
void CSGOMatchList::Refresh()
{
CMsgGCCStrike15_v2_MatchListRequestRecentUserGames request;
request.set_accountid(SteamUser()->GetSteamID().GetAccountID());
if (CSGOClient::GetInstance()->SendGCMessage(k_EMsgGCCStrike15_v2_MatchListRequestRecentUserGames, &request) != k_EGCResultOK)
throw BoilerException("Failed to send EMsgGCCStrike15_v2_MatchListRequestRecentUserGames");
}
void CallsignTagInfo::LoadFromRegistry()
{
char szSteamClanID[120];
szSteamClanID[0] = '\0';
DWORD cbClanID = sizeof(szSteamClanID);
char szSteamOfficerToken[5];
szSteamOfficerToken[0] = '\0';
DWORD cbSteamOfficerToken = sizeof(szSteamOfficerToken);
HKEY hKey;
DWORD dwType;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, ALLEGIANCE_REGISTRY_KEY_ROOT, 0, KEY_READ, &hKey))
{
RegQueryValueEx(hKey, "SteamClanID", NULL, &dwType, (BYTE *)&szSteamClanID, &cbClanID);
RegQueryValueEx(hKey, "SteamOfficerToken", NULL, &dwType, (BYTE *)&szSteamOfficerToken, &cbSteamOfficerToken);
RegCloseKey(hKey);
}
CSteamID targetGroupID(strtoull(szSteamClanID, NULL, NULL));
CSteamID currentUser = SteamUser()->GetSteamID();
int clanCount = SteamFriends()->GetClanCount();
for (int i = 0; i < clanCount; i++)
{
if (targetGroupID == SteamFriends()->GetClanByIndex(i))
{
m_steamGroupID = targetGroupID.ConvertToUint64();
break;
}
}
UpdateStringValues(szSteamOfficerToken);
}
CStatsAndAchievements::CStatsAndAchievements( IGameEngine *pGameEngine )
:
m_pGameEngine( pGameEngine ),
m_pSteamUser( NULL ),
m_pSteamUserStats( NULL ),
m_GameID( SteamUtils()->GetAppID() ),
m_CallbackUserStatsReceived( this, &CStatsAndAchievements::OnUserStatsReceived ),
m_CallbackUserStatsStored( this, &CStatsAndAchievements::OnUserStatsStored ),
m_CallbackAchievementStored( this, &CStatsAndAchievements::OnAchievementStored ),
m_CallbackPS3TrophiesInstalled( this, &CStatsAndAchievements::OnPS3TrophiesInstalled )
{
m_pSteamUser = SteamUser();
m_pSteamUserStats = SteamUserStats();
m_bRequestedStats = false;
m_bStatsValid = false;
m_bStoreStats = false;
m_flGameFeetTraveled = 0;
m_nTotalGamesPlayed = 0;
m_nTotalNumWins = 0;
m_nTotalNumLosses = 0;
m_flTotalFeetTraveled = 0;
m_flMaxFeetTraveled = 0;
m_flAverageSpeed = 0;
m_hDisplayFont = pGameEngine->HCreateFont( ACHDISP_FONT_HEIGHT, FW_MEDIUM, false, "Arial" );
if ( !m_hDisplayFont )
OutputDebugString( "Stats font was not created properly, text won't draw\n" );
m_bInstalledPS3Trophies = false;
m_bStartedPS3TrophyInstall = false;
}
int CSGOMatchList::getOwnIndex(const CDataGCCStrike15_v2_MatchInfo& info)
{
uint32 accid = SteamUser()->GetSteamID().GetAccountID();
for (int i = 0; i < info.roundstats().reservation().account_ids().size(); ++i)
if (info.roundstats().reservation().account_ids(i) == accid)
return i;
throw "unable to find own accid in matchinfo";
}
void FOnlineAsyncTaskSteamDeleteUserFile::Tick()
{
bWasSuccessful = false;
if (SteamRemoteStorage() && FileName.Len() > 0)
{
CSteamID SteamId(*(uint64*)UserId.GetBytes());
if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId)
{
bool bCloudDeleteSuccess = true;
if (bShouldCloudDelete)
{
// Remove the cloud flag, the file remains safely available on the local machine
bCloudDeleteSuccess = SteamRemoteStorage()->FileForget(TCHAR_TO_UTF8(*FileName));
}
bool bLocalDeleteSuccess = true;
if (bShouldLocallyDelete)
{
bLocalDeleteSuccess = false;
// Only clear the tables if we're permanently deleting the file
// Need to make sure nothing async is happening first (this is a formality as nothing in Steam actually is)
IOnlineUserCloudPtr UserCloud = Subsystem->GetUserCloudInterface();
if (UserCloud->ClearFile(UserId, FileName))
{
// Permanent delete
bLocalDeleteSuccess = SteamRemoteStorage()->FileDelete(TCHAR_TO_UTF8(*FileName));
Subsystem->ClearUserCloudMetadata(UserId, FileName);
}
}
bWasSuccessful = bCloudDeleteSuccess && bLocalDeleteSuccess;
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Can only delete cloud files for logged in user."));
}
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled."));
}
bIsComplete = true;
}
Ref<_SteamUser> Steam::get_user()
{
if ( SteamFriends() != NULL && yourUser == NULL )
{
CSteamID cSteamID = SteamUser()->GetSteamID();
yourUser = Ref<_SteamUser>( memnew( _SteamUser(cSteamID) ) );
}
return yourUser;
}
void SteamCallbackManager::onLobbyCreated(LobbyCreated_t* pCallback) {
if (pCallback->m_eResult == k_EResultOK) {
qDebug() << "Inviting steam friends" << pCallback->m_ulSteamIDLobby;
auto url = SteamFriends()->GetFriendRichPresence(SteamUser()->GetSteamID(), "connect");
SteamMatchmaking()->SetLobbyData(pCallback->m_ulSteamIDLobby, "connect", url);
SteamFriends()->ActivateGameOverlayInviteDialog(pCallback->m_ulSteamIDLobby);
}
}
void search_content()
{
handle = SteamUGC()->CreateQueryUserUGCRequest(
SteamUser()->GetSteamID().GetAccountID(), k_EUserUGCList_Published,
k_EUGCMatchingUGCType_Items,
k_EUserUGCListSortOrder_CreationOrderDesc,
0, CHOWDREN_STEAM_APPID, 1);
SteamAPICall_t call_handle = SteamUGC()->SendQueryUGCRequest(handle);
content_call.Set(call_handle, this, &SubCallback::on_content_callback);
}
FVoiceEngineSteam::FVoiceEngineSteam(FOnlineSubsystemSteam* InSteamSubsystem) :
SteamSubsystem(InSteamSubsystem),
OwningUserIndex(INVALID_INDEX),
bPendingFinalCapture(false),
bIsCapturing(false),
SerializeHelper(NULL)
{
SteamUserPtr = SteamUser();
SteamFriendsPtr = SteamFriends();
}
int SteamObject::get_user_id()
{
#ifdef CHOWDREN_ENABLE_STEAM
if (!global_steam_obj.initialized)
return 0;
return SteamUser()->GetSteamID().GetAccountID();
#else
return 0;
#endif
}
void SteamTicketRequests::stopAll() {
auto steamUser = SteamUser();
if (steamUser) {
for (const auto& pendingTicket : _pendingTickets) {
steamUser->CancelAuthTicket(pendingTicket.authTicket);
pendingTicket.callback(INVALID_TICKET);
}
}
_pendingTickets.clear();
}
void FOnlineAsyncTaskSteamEnumerateUserFiles::Tick()
{
bIsComplete = true;
bWasSuccessful = false;
if (SteamRemoteStorage())
{
CSteamID SteamId(*(uint64*)UserId.GetBytes());
if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId)
{
//SteamSubsystem->GetUserCloudInterface()->DumpCloudState(UserId);
FScopeLock ScopeLock(&Subsystem->UserCloudDataLock);
// Get or create the user metadata entry and empty it
FSteamUserCloudData* UserMetadata = Subsystem->GetUserCloudEntry(UserId);
UserMetadata->CloudMetadata.Empty();
// Fill in the metadata entries
const int32 FileCount = (int32) SteamRemoteStorage()->GetFileCount();
for (int32 FileIdx = 0; FileIdx < FileCount; FileIdx++)
{
int32 FileSize = 0;
const char *FileName = SteamRemoteStorage()->GetFileNameAndSize(FileIdx, &FileSize);
new (UserMetadata->CloudMetadata) FCloudFileHeader(UTF8_TO_TCHAR(FileName), UTF8_TO_TCHAR(FileName), int32(FileSize));
//SteamSubsystem->GetUserCloudInterface()->DumpCloudFileState(UserId, FileName);
}
bWasSuccessful = true;
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Can only enumerate cloud files for logged in user."));
}
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled."));
}
}
void SteamTicketRequests::stopRequest(HAuthTicket authTicket) {
auto it = std::find_if(_pendingTickets.begin(), _pendingTickets.end(), [&authTicket](const PendingTicket& pendingTicket) {
return pendingTicket.authTicket == authTicket;
});
if (it != _pendingTickets.end()) {
SteamUser()->CancelAuthTicket(it->authTicket);
it->callback(INVALID_TICKET);
_pendingTickets.erase(it);
}
}
void FOnlineAsyncTaskSteamReadSharedFile::Tick()
{
ISteamUtils* SteamUtilsPtr = SteamUtils();
check(SteamUtilsPtr);
if (!bInit)
{
if (SteamRemoteStorage() && SharedHandle.IsValid())
{
if (SteamUser()->BLoggedOn())
{
// Actual request to download the file from Steam
CallbackHandle = SteamRemoteStorage()->UGCDownload(*(UGCHandle_t*)SharedHandle.GetBytes(), 0);
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Steam user not logged in."));
}
}
else
{
UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled."));
}
bInit = true;
}
if (CallbackHandle != k_uAPICallInvalid)
{
bool bFailedCall = false;
// Poll for completion status
bIsComplete = SteamUtilsPtr->IsAPICallCompleted(CallbackHandle, &bFailedCall) ? true : false;
if (bIsComplete)
{
bool bFailedResult;
// Retrieve the callback data from the request
bool bSuccessCallResult = SteamUtilsPtr->GetAPICallResult(CallbackHandle, &CallbackResults, sizeof(CallbackResults), CallbackResults.k_iCallback, &bFailedResult);
bWasSuccessful = (bSuccessCallResult ? true : false) &&
(!bFailedCall ? true : false) &&
(!bFailedResult ? true : false) &&
((CallbackResults.m_eResult == k_EResultOK) ? true : false);
}
}
else
{
// Invalid API call
bIsComplete = true;
bWasSuccessful = false;
}
}
bool TPortal_Startup()
{
bool bOkay = SteamAPI_Init();
if (!bOkay)
return false;
// 127.0.0.1 = 2130706433
SteamUser()->InitiateGameConnection( NULL, 0, k_steamIDNonSteamGS, 2130706433, 30203, false );
SteamUtils()->SetOverlayNotificationPosition( k_EPositionBottomLeft );
return true;
}
void CClientSteamContext::UpdateLoggedOnState()
{
bool bPreviousLoggedOn = m_bLoggedOn;
m_bLoggedOn = ( SteamUser() && SteamUtils() && SteamUser()->BLoggedOn() );
if ( !bPreviousLoggedOn && m_bLoggedOn )
{
// update Steam info
m_SteamIDLocalPlayer = SteamUser()->GetSteamID();
m_nUniverse = SteamUtils()->GetConnectedUniverse();
m_nAppID = SteamUtils()->GetAppID();
}
if ( bPreviousLoggedOn != m_bLoggedOn )
{
// Notify any listeners of the change in logged on state
SteamLoggedOnChange_t loggedOnChange;
loggedOnChange.bPreviousLoggedOn = bPreviousLoggedOn;
loggedOnChange.bLoggedOn = m_bLoggedOn;
InvokeCallbacks( loggedOnChange );
}
}
// The constructor :o
CStatsAndAchievements::CStatsAndAchievements(const char* sAIModel) :
m_pSteamUser( NULL ),
m_pSteamUserStats( NULL ),
m_GameID( SteamUtils()->GetAppID() ),
m_CallbackUserStatsStored( this, &CStatsAndAchievements::OnUserStatsStored ),
m_CallbackAchievementStored( this, &CStatsAndAchievements::OnAchievementStored ),
m_CallbackUserStatsReceived( this, &CStatsAndAchievements::OnUserStatsReceived )
{
m_pSteamUser = SteamUser();
m_pSteamUserStats = SteamUserStats();
m_bRequestedStats = false;
m_bStatsValid = false;
m_sAIModel = sAIModel;
}
int Steam::init()
{
//printf("Godot steam init\n");
isInitSuccess = SteamAPI_Init();
int err = FAILED;
if (isInitSuccess)
{ err = OK; }
if ( !SteamAPI_IsSteamRunning() )
{ err = ERR_NO_CLIENT; }
else if ( !SteamUser()->BLoggedOn() )
{ err = ERR_NO_CONNECTION; }
return err;
}
void SteamCallbackManager::onLobbyEnter(LobbyEnter_t* pCallback) {
if (pCallback->m_EChatRoomEnterResponse != k_EChatRoomEnterResponseSuccess) {
qWarning() << "An error occured while joing the Steam lobby:" << pCallback->m_EChatRoomEnterResponse;
return;
}
qDebug() << "Entered Steam lobby" << pCallback->m_ulSteamIDLobby;
if (SteamMatchmaking()->GetLobbyOwner(pCallback->m_ulSteamIDLobby) != SteamUser()->GetSteamID()) {
auto url = SteamMatchmaking()->GetLobbyData(pCallback->m_ulSteamIDLobby, "connect");
qDebug() << "Jumping to" << url;
parseUrlAndGo(url);
SteamMatchmaking()->LeaveLobby(pCallback->m_ulSteamIDLobby);
}
}
bool FOnlineAchievementsSteam::ResetAchievements(const FUniqueNetId& PlayerId)
{
if (!bHaveConfiguredAchievements)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Steam achievements have not been configured in .ini"));
return false;
}
FUniqueNetIdSteam SteamId(PlayerId);
// check if this is our player (cannot report for someone else)
if (SteamUser() == NULL || SteamUser()->GetSteamID() != SteamId)
{
// we don't have achievements
UE_LOG_ONLINE(Warning, TEXT("Cannot clear Steam achievements for non-local player %s"), *PlayerId.ToString());
return false;
}
const TArray<FOnlineAchievement> * PlayerAch = PlayerAchievements.Find(SteamId);
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 false;
}
const int32 AchNum = PlayerAch->Num();
for (int32 AchIdx = 0; AchIdx < AchNum; ++AchIdx)
{
SteamUserStats()->ClearAchievement(TCHAR_TO_UTF8(*(*PlayerAch)[ AchIdx ].Id));
}
// TODO: provide a separate method to just store stats?
StatsInt->FlushLeaderboards(FName(TEXT("UNUSED")));
return true;
};
HAuthTicket SteamTicketRequests::startRequest(TicketRequestCallback callback) {
static const uint32 MAX_TICKET_SIZE { 1024 };
uint32 ticketSize { 0 };
char ticket[MAX_TICKET_SIZE];
auto authTicket = SteamUser()->GetAuthSessionTicket(ticket, MAX_TICKET_SIZE, &ticketSize);
qDebug() << "Got Steam auth session ticket:" << authTicket;
if (authTicket == k_HAuthTicketInvalid) {
qWarning() << "Auth session ticket is invalid.";
callback(INVALID_TICKET);
} else {
PendingTicket pendingTicket{ authTicket, QByteArray(ticket, ticketSize).toHex(), callback };
_pendingTickets.push_back(pendingTicket);
}
return authTicket;
}
//-----------------------------------------------------------------------------
// Purpose: Tell the server about any updates we have had client-side
//-----------------------------------------------------------------------------
bool CShip::BGetClientUpdateData( ClientSpaceWarUpdateData_t *pUpdateData )
{
// Limit the rate at which we send updates, even if our internal frame rate is higher
if ( m_pGameEngine->GetGameTickCount() - m_ulLastClientUpdateTick < 1000.0f/CLIENT_UPDATE_SEND_RATE )
return false;
m_ulLastClientUpdateTick = m_pGameEngine->GetGameTickCount();
// Update playername before sending
if ( m_bIsLocalPlayer )
{
m_SpaceWarClientUpdateData.SetPlayerName( SteamFriends()->GetFriendPersonaName( SteamUser()->GetSteamID() ) );
}
memcpy( pUpdateData, &m_SpaceWarClientUpdateData, sizeof( ClientSpaceWarUpdateData_t ) );
memset( &m_SpaceWarClientUpdateData, 0, sizeof( m_SpaceWarClientUpdateData ) );
return true;
}
