//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CAvatarImagePanel::SetPlayer( C_BasePlayer *pPlayer ) { if ( GetImage() ) { ((CAvatarImage*)GetImage())->ClearAvatarSteamID(); } #ifndef NO_STEAM if ( pPlayer && SteamUtils() ) { int iIndex = pPlayer->entindex(); player_info_t pi; if ( engine->GetPlayerInfo(iIndex, &pi) ) { if ( pi.friendsID ) { CSteamID steamIDForPlayer( pi.friendsID, 1, SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual ); if ( !GetImage() ) { CAvatarImage *pImage = new CAvatarImage(); SetImage( pImage ); } ((CAvatarImage*)GetImage())->SetAvatarSteamID( steamIDForPlayer ); // Indent the image. These are deliberately non-resolution-scaling. int iIndent = 2; GetImage()->SetPos( iIndent, iIndent ); GetImage()->SetSize( GetWide()-(iIndent*2), GetTall()-(iIndent*2) ); } } } #endif }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CAvatarImage::SetAvatarSteamID( CSteamID steamIDUser ) { ClearAvatarSteamID(); #ifndef NO_STEAM if ( SteamFriends() && SteamUtils() ) { int iAvatar = SteamFriends()->GetFriendAvatar( steamIDUser ); /* // See if it's in our list already */ uint32 wide, tall; if ( SteamUtils()->GetImageSize( iAvatar, &wide, &tall ) ) { int cubImage = wide * tall * 4; byte *rgubDest = (byte*)_alloca( cubImage ); SteamUtils()->GetImageRGBA( iAvatar, rgubDest, cubImage ); InitFromRGBA( rgubDest, wide, tall ); /* // put it in the list RGBAImage *pRGBAImage = new RGBAImage( rgubDest, wide, tall ); int iImageList = m_pImageList->AddImage( pRGBAImage ); m_mapAvatarToIImageList.Insert( iAvatar, iImageList ); */ } } #endif return m_bValid; }
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; }
// STEAM Stats CSteamStats::CSteamStats(Stat_t *Stats, int NumStats) : m_iAppID( 0 ), m_bInitialized( false ), m_CallbackUserStatsReceived( this, &CSteamStats::OnUserStatsReceived ), m_CallbackUserStatsStored( this, &CSteamStats::OnUserStatsStored ) { m_iAppID = SteamUtils()->GetAppID(); m_pStats = Stats; m_iNumStats = NumStats; RequestStats(); }
CSteamAchievements::CSteamAchievements(Achievement_t *Achievements, int NumAchievements) : m_iAppID(0), m_bInitialized(false), m_CallbackUserStatsReceived(this, &CSteamAchievements::OnUserStatsReceived), m_CallbackUserStatsStored(this, &CSteamAchievements::OnUserStatsStored), m_CallbackAchievementStored(this, &CSteamAchievements::OnAchievementStored) { m_iAppID = SteamUtils()->GetAppID(); m_pAchievements = Achievements; m_iNumAchievements = NumAchievements; }
//----------------------------------------------------------------------------- // 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 ); } } }
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 ); } }
/** * Called by the SteamAPI when a server has successfully responded */ void FOnlineAsyncTaskSteamFindServerBase::ServerResponded(HServerListRequest Request, int iServer) { ElapsedTime = 0.0f; gameserveritem_t* Server = SteamMatchmakingServersPtr->GetServerDetails(Request, iServer); if (Server != NULL) { // Filter out servers that don't match our appid here if (!Server->m_bDoNotRefresh && Server->m_nAppID == SteamUtils()->GetAppID()) { ParseSearchResult(Server); } } }
// 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; }
void FOnlineAsyncTaskSteamWriteSharedFile::Tick() { ISteamUtils* SteamUtilsPtr = SteamUtils(); check(SteamUtilsPtr); if (!bInit) { if (WriteUserFile(UserId, FileName, Contents)) { // Simply mark the file as shared, will trigger a delegate when upload is complete CallbackHandle = SteamRemoteStorage()->FileShare(TCHAR_TO_UTF8(*FileName)); } 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; } }
/** * Called by the SteamAPI when a server has failed to respond */ void FOnlineAsyncTaskSteamFindServerBase::ServerFailedToRespond(HServerListRequest Request, int iServer) { ElapsedTime = 0.0f; gameserveritem_t* Server = SteamMatchmakingServersPtr->GetServerDetails(Request, iServer); if (Server != NULL) { TSharedRef<FInternetAddr> ServerAddr = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr(); int32 ServerQueryPort = 0; ServerAddr->SetIp(Server->m_NetAdr.GetIP()); ServerAddr->SetPort(Server->m_NetAdr.GetConnectionPort()); ServerQueryPort = Server->m_NetAdr.GetQueryPort(); UE_LOG_ONLINE(Warning, TEXT("Failed to respond IP:%s"), *ServerAddr->ToString(false)); // Filter out servers that don't match our appid here if (Server->m_nAppID == SteamUtils()->GetAppID()) { } } }
void SteamGlobal::receive_callback(UserStatsReceived_t * callback) { if (SteamUtils()->GetAppID() != callback->m_nGameID) return; has_data = true; }
SW_PY bool IsSteamRunningInVR() { return SteamUtils()->IsSteamRunningInVR(); }
SW_PY bool IsOverlayEnabled() { return SteamUtils()->IsOverlayEnabled(); }
// Returns true if the overlay is running & the user can access it. The overlay process could take a few seconds to // start & hook the game process, so this function will initially return false while the overlay is loading. bool Steam::overlay_is_enabled() { if ( SteamUtils() == NULL ) { return false; } return SteamUtils()->IsOverlayEnabled(); }
/** * Give the async task time to do its work * Can only be called on the async task manager thread */ void FOnlineAsyncTaskSteamFindServerBase::Tick() { ISteamUtils* SteamUtilsPtr = SteamUtils(); check(SteamUtilsPtr); if (!bInit) { SteamMatchmakingServersPtr = SteamMatchmakingServers(); check(SteamMatchmakingServersPtr); int32 NumFilters = 0; MatchMakingKeyValuePair_t* Filters = NULL; CreateQuery(&Filters, NumFilters); #if DEBUG_STEAM_FILTERS for (int32 FilterIdx=0; FilterIdx<NumFilters; FilterIdx++) { UE_LOG_ONLINE(Verbose, TEXT(" \"%s\" \"%s\" "), UTF8_TO_TCHAR(Filters[FilterIdx].m_szKey), UTF8_TO_TCHAR(Filters[FilterIdx].m_szValue)); } #endif if (SearchSettings->MaxSearchResults <= 0) { UE_LOG_ONLINE(Warning, TEXT("FOnlineAsyncTaskSteamFindServerBase::Tick - SearchSettings->MaxSearchResults should be greater than 0, but it is currently %d. No search results will be found."), SearchSettings->MaxSearchResults); } ServerListRequestHandle = SteamMatchmakingServersPtr->RequestInternetServerList(Subsystem->GetSteamAppId(), &Filters, NumFilters, this); if (ServerListRequestHandle == NULL) { // Invalid API call bIsComplete = true; bWasSuccessful = false; } // Preallocate space for results PendingSearchResults.Empty(SearchSettings->MaxSearchResults); delete [] Filters; bInit = true; } ElapsedTime += 1.0f/16.0f; // Cancel query when we've reached our requested limit bool bReachedSearchLimit = (SearchSettings->SearchResults.Num() >= SearchSettings->MaxSearchResults) ? true : false; // Check for activity timeout bool bTimedOut = (ElapsedTime >= ASYNC_TASK_TIMEOUT) ? true : false; // Check for proper completion bool bServerSearchComplete = (bServerRefreshComplete && PendingSearchResults.Num() == 0) ? true : false; if ( bReachedSearchLimit || bTimedOut || bServerSearchComplete) { bIsComplete = true; bWasSuccessful = true; } if (bIsComplete) { // Cancel further server queries (may trigger RefreshComplete delegate) if (ServerListRequestHandle != NULL) { SteamMatchmakingServersPtr->CancelQuery(ServerListRequestHandle); SteamMatchmakingServersPtr->ReleaseRequest(ServerListRequestHandle); ServerListRequestHandle = NULL; } // Cancel further rules queries for (int32 PendingIdx=0; PendingIdx<PendingSearchResults.Num(); ++PendingIdx) { PendingSearchResults[PendingIdx].CancelQuery(); } PendingSearchResults.Empty(); } }
SW_PY const char* GetIPCountry() { return SteamUtils()->GetIPCountry(); }
void init(const std::vector<AchievementInfo>& achievementInfos) //const char *pchCmdLine, HINSTANCE hInstance, int nCmdShow) { g_AchievementInfosCopy = achievementInfos; for (size_t i = 0; i < achievementInfos.size(); ++i) { Achievement_t achievementData; achievementData.m_eAchievementID = i; achievementData.m_pchAchievementID = g_AchievementInfosCopy[i].id.c_str(); strncpy(achievementData.m_rgchName, g_AchievementInfosCopy[i].name.c_str(), 128); strncpy(achievementData.m_rgchDescription, g_AchievementInfosCopy[i].description.c_str(), 128); achievementData.m_bAchieved = false; achievementData.m_iIconImage = 0; g_Achievements.push_back(achievementData); } if (SteamAPI_RestartAppIfNecessary(k_uAppIdInvalid)) { // if Steam is not running or the game wasn't started through Steam, SteamAPI_RestartAppIfNecessary starts the // local Steam client and also launches this game again. // Once you get a public Steam AppID assigned for this game, you need to replace k_uAppIdInvalid with it and // removed steam_appid.txt from the game depot. AssertMessage(false, "SteamAPI_RestartAppIfNecessary failed"); } // Init Steam CEG if (!Steamworks_InitCEGLibrary()) { Utils::sleepMs(1000); if (!Steamworks_InitCEGLibrary()) // try twice - it may be a glitch in the network? { AssertMessage(false, "Steam must be running to play this game (InitDrmLibrary() failed)."); } } // Initialize SteamAPI, if this fails we bail out since we depend on Steam for lots of stuff. // You don't necessarily have to though if you write your code to check whether all the Steam // interfaces are NULL before using them and provide alternate paths when they are unavailable. // // This will also load the in-game steam overlay dll into your process. That dll is normally // injected by steam when it launches games, but by calling this you cause it to always load, // even when not launched via steam. if (!SteamAPI_Init()) { Utils::sleepMs(1000); if (!SteamAPI_Init()) { AssertMessage(false, "Steam must be running to play this game (SteamAPI_Init() failed).\n"); } } // Create the SteamAchievements object if Steam was successfully initialized g_SteamAchievements = new CSteamAchievements(&g_Achievements[0], g_Achievements.size()); bool res = g_SteamAchievements->RequestStats(); if (!res) { Utils::sleepMs(1000); res = g_SteamAchievements->RequestStats(); if (!res) { AssertMessage(false, "Could not get stats from Steam.\nPlease check that your Internet connection is working correctly and that Steam is up.\n"); } } // set our debug handler SteamClient()->SetWarningMessageHook(&SteamAPIDebugTextHook); // Tell Steam where it's overlay should show notification dialogs, this can be top right, top left, // bottom right, bottom left. The default position is the bottom left if you don't call this. // Generally you should use the default and not call this as users will be most comfortable with // the default position. The API is provided in case the bottom right creates a serious conflict // with important UI in your game. SteamUtils()->SetOverlayNotificationPosition(k_EPositionTopRight); // Ensure that the user has logged into Steam. This will always return true if the game is launched // from Steam, but if Steam is at the login prompt when you run your game from the debugger, it // will return false. if (!SteamUser()->BLoggedOn()) { Utils::sleepMs(1000); if (!SteamUser()->BLoggedOn()) { AssertMessage(false, "Steam user must be logged in to play this game (SteamUser()->BLoggedOn() returned false).\n"); } } // We are going to use the controller interface, initialize it, which is a seperate step as it // create a new thread in the game proc and we don't want to force that on games that don't // have native Steam controller implementations #ifdef USES_LINUX std::string rgchCWDstr = Utils::convertWStringToString(Utils::getCurrentDirectoryUnicode(), true); const char* rgchCWD = rgchCWDstr.c_str(); #else char rgchCWD[1024]; _getcwd( rgchCWD, sizeof( rgchCWD ) ); #endif char rgchFullPath[1024]; #if defined(_WIN32) _snprintf(rgchFullPath, sizeof(rgchFullPath), "%s\\%s", rgchCWD, "controller.vdf");//.c_str() #elif defined(OSX) // hack for now, because we do not have utility functions available for finding the resource path // alternatively we could disable the SteamController init on OS X _snprintf(rgchFullPath, sizeof(rgchFullPath), "%s/steamworksexample.app/Contents/Resources/%s", rgchCWD, "controller.vdf"); #else _snprintf(rgchFullPath, sizeof(rgchFullPath), "%s/%s", rgchCWD, "controller.vdf"); #endif if (!SteamController()->Init(rgchFullPath)) { AssertMessage(false, "Steam Controller Init failed. Is controller.vdf in the current working directory?\n"); } /*bool bUseVR = SteamUtils()->IsSteamRunningInVR(); const char *pchServerAddress, *pchLobbyID; ParseCommandLine(pchCmdLine, &pchServerAddress, &pchLobbyID, &bUseVR);*/ // do a DRM self check Steamworks_SelfCheck(); // init VR before we make the window // Construct a new instance of the game engine // bugbug jmccaskey - make screen resolution dynamic, maybe take it on command line? /*IGameEngine *pGameEngine = #if defined(_WIN32) new CGameEngineWin32(hInstance, nCmdShow, 1024, 768, bUseVR); #elif defined(OSX) CreateGameEngineOSX(); #elif defined(SDL) CreateGameEngineSDL(bUseVR); #else #error Need CreateGameEngine() #endif*/ }
void SteamUtilsCallback::enableWarningMessageHook(bool enabled) { s_messageHookInstance = enabled ? this : NULL; SteamUtils()->SetWarningMessageHook(enabled ? &SteamAPIDebugTextHook : NULL); }
bool SteamVR::Init() { if (SteamAPI_RestartAppIfNecessary(k_uAppIdInvalid)) { // if Steam is not running or the game wasn't started through Steam, SteamAPI_RestartAppIfNecessary starts the // local Steam client and also launches this game again. // Once you get a public Steam AppID assigned for this game, you need to replace k_uAppIdInvalid with it and // removed steam_appid.txt from the game depot. return false; } if (!SteamAPI_Init()) { Log("SteamAPI_Init() failed\n"); return false; } // set our debug handler //SteamClient()->SetWarningMessageHook(&SteamAPIDebugTextHook); // Ensure that the user has logged into Steam. This will always return true if the game is launched // from Steam, but if Steam is at the login prompt when you run your game from the debugger, it // will return false. if (!SteamUser()->BLoggedOn()) { Log("Steam user is not logged in\n"); Log("Steam user must be logged in to play this game (SteamUser()->BLoggedOn() returned false).\n"); return false; } // Initialize steam controller if connected char rgchCWD[1024]; _getcwd(rgchCWD, sizeof(rgchCWD)); char rgchFullPath[1024]; _snprintf(rgchFullPath, sizeof(rgchFullPath), "%s\\%s", rgchCWD, "controller.vdf"); if (!SteamController()->Init(rgchFullPath)) { Log("SteamController()->Init() failed\n"); Log("Steam Controller Init failed. Is controller.vdf in the current working directory?\n"); return false; } // Need to run from Steam UI to work I think bool UseVR = SteamUtils()->IsSteamRunningInVR(); // Set UseVR to true for testing UseVR = true; // Init VR if (!UseVR) { mVRHmd = NULL; } else { vr::HmdError error; mVRHmd = vr::VR_Init(&error); if (!mVRHmd) { Log("Failed to initialize VR."); Log("Game will run without VR."); return false; } } Log("SteamVR Initialized"); return true; }
int Steam::get_appid() { if ( SteamUtils() == NULL ) { return 0; } return SteamUtils()->GetAppID(); }
// Change position(corner) at which notifications (messages, etc.) will be displayed // TOP_LEFT=0 | TOP_RIGHT=1 | BOT_LEFT=2 | BOT_RIGHT=3 void Steam::overlay_set_notify_pos( int pos ) { if ((pos < 0) || (pos > 3) || (SteamUtils() == NULL)) { return; } SteamUtils()->SetOverlayNotificationPosition( ENotificationPosition(pos) ) ; }
SW_PY uint32 GetSecondsSinceAppActive() { return SteamUtils()->GetSecondsSinceAppActive(); }
SW_PY uint32 GetSecondsSinceComputerActive() { return SteamUtils()->GetSecondsSinceComputerActive(); }
static int RealMain( const char *pchCmdLine, HINSTANCE hInstance, int nCmdShow ) { if ( SteamAPI_RestartAppIfNecessary( k_uAppIdInvalid ) ) { // if Steam is not running or the game wasn't started through Steam, SteamAPI_RestartAppIfNecessary starts the // local Steam client and also launches this game again. // Once you get a public Steam AppID assigned for this game, you need to replace k_uAppIdInvalid with it and // removed steam_appid.txt from the game depot. return EXIT_FAILURE; } // Init Steam CEG if ( !Steamworks_InitCEGLibrary() ) { OutputDebugString( "Steamworks_InitCEGLibrary() failed\n" ); Alert( "Fatal Error", "Steam must be running to play this game (InitDrmLibrary() failed).\n" ); return EXIT_FAILURE; } // Initialize SteamAPI, if this fails we bail out since we depend on Steam for lots of stuff. // You don't necessarily have to though if you write your code to check whether all the Steam // interfaces are NULL before using them and provide alternate paths when they are unavailable. // // This will also load the in-game steam overlay dll into your process. That dll is normally // injected by steam when it launches games, but by calling this you cause it to always load, // even when not launched via steam. if ( !SteamAPI_Init() ) { OutputDebugString( "SteamAPI_Init() failed\n" ); Alert( "Fatal Error", "Steam must be running to play this game (SteamAPI_Init() failed).\n" ); return EXIT_FAILURE; } // set our debug handler SteamClient()->SetWarningMessageHook( &SteamAPIDebugTextHook ); // Tell Steam where it's overlay should show notification dialogs, this can be top right, top left, // bottom right, bottom left. The default position is the bottom left if you don't call this. // Generally you should use the default and not call this as users will be most comfortable with // the default position. The API is provided in case the bottom right creates a serious conflict // with important UI in your game. SteamUtils()->SetOverlayNotificationPosition( k_EPositionTopRight ); // Ensure that the user has logged into Steam. This will always return true if the game is launched // from Steam, but if Steam is at the login prompt when you run your game from the debugger, it // will return false. if ( !SteamUser()->BLoggedOn() ) { OutputDebugString( "Steam user is not logged in\n" ); Alert( "Fatal Error", "Steam user must be logged in to play this game (SteamUser()->BLoggedOn() returned false).\n" ); return EXIT_FAILURE; } // We are going to use the controller interface, initialize it, which is a seperate step as it // create a new thread in the game proc and we don't want to force that on games that don't // have native Steam controller implementations char rgchCWD[1024]; _getcwd( rgchCWD, sizeof( rgchCWD ) ); char rgchFullPath[1024]; #if defined(_WIN32) _snprintf( rgchFullPath, sizeof( rgchFullPath ), "%s\\%s", rgchCWD, "controller.vdf" ); #elif defined(OSX) // hack for now, because we do not have utility functions available for finding the resource path // alternatively we could disable the SteamController init on OS X _snprintf( rgchFullPath, sizeof( rgchFullPath ), "%s/steamworksexample.app/Contents/Resources/%s", rgchCWD, "controller.vdf" ); #else _snprintf( rgchFullPath, sizeof( rgchFullPath ), "%s/%s", rgchCWD, "controller.vdf" ); #endif if( !SteamController()->Init( rgchFullPath ) ) { OutputDebugString( "SteamController()->Init() failed\n" ); Alert( "Fatal Error", "Steam Controller Init failed. Is controller.vdf in the current working directory?\n" ); return EXIT_FAILURE; } bool bUseVR = SteamUtils()->IsSteamRunningInVR(); const char *pchServerAddress, *pchLobbyID; ParseCommandLine( pchCmdLine, &pchServerAddress, &pchLobbyID, &bUseVR ); // do a DRM self check Steamworks_SelfCheck(); // init VR before we make the window // Construct a new instance of the game engine // bugbug jmccaskey - make screen resolution dynamic, maybe take it on command line? IGameEngine *pGameEngine = #if defined(_WIN32) new CGameEngineWin32( hInstance, nCmdShow, 1024, 768, bUseVR ); #elif defined(OSX) CreateGameEngineOSX(); #elif defined(SDL) CreateGameEngineSDL( bUseVR ); #else #error Need CreateGameEngine() #endif // This call will block and run until the game exits RunGameLoop( pGameEngine, pchServerAddress, pchLobbyID ); // Shutdown the SteamAPI SteamController()->Shutdown(); SteamAPI_Shutdown(); // Shutdown Steam CEG Steamworks_TermCEGLibrary(); // exit return EXIT_SUCCESS; }
SW_PY uint32 GetServerRealTime() { return SteamUtils()->GetServerRealTime(); }
// Steam Utilities SW_PY uint8 GetCurrentBatteryPower() { return SteamUtils()->GetCurrentBatteryPower(); }
bool FOnlineSubsystemSteam::InitSteamworksClient(bool bRelaunchInSteam, int32 SteamAppId) { bSteamworksClientInitialized = false; // If the game was not launched from within Steam, but is supposed to, trigger a Steam launch and exit if (bRelaunchInSteam && SteamAppId != 0 && SteamAPI_RestartAppIfNecessary(SteamAppId)) { if (FPlatformProperties::IsGameOnly() || FPlatformProperties::IsServerOnly()) { UE_LOG_ONLINE(Log, TEXT("Game restarting within Steam client, exiting")); FPlatformMisc::RequestExit(false); } return bSteamworksClientInitialized; } // Otherwise initialize as normal else { // Steamworks needs to initialize as close to start as possible, so it can hook its overlay into Direct3D, etc. bSteamworksClientInitialized = (SteamAPI_Init() ? true : false); // Test all the Steam interfaces #define GET_STEAMWORKS_INTERFACE(Interface) \ if (Interface() == nullptr) \ { \ UE_LOG_ONLINE(Warning, TEXT("Steamworks: %s() failed!"), TEXT(#Interface)); \ bSteamworksClientInitialized = false; \ } \ // GSteamUtils GET_STEAMWORKS_INTERFACE(SteamUtils); // GSteamUser GET_STEAMWORKS_INTERFACE(SteamUser); // GSteamFriends GET_STEAMWORKS_INTERFACE(SteamFriends); // GSteamRemoteStorage GET_STEAMWORKS_INTERFACE(SteamRemoteStorage); // GSteamUserStats GET_STEAMWORKS_INTERFACE(SteamUserStats); // GSteamMatchmakingServers GET_STEAMWORKS_INTERFACE(SteamMatchmakingServers); // GSteamApps GET_STEAMWORKS_INTERFACE(SteamApps); // GSteamNetworking GET_STEAMWORKS_INTERFACE(SteamNetworking); // GSteamMatchmaking GET_STEAMWORKS_INTERFACE(SteamMatchmaking); #undef GET_STEAMWORKS_INTERFACE } if (bSteamworksClientInitialized) { bool bIsSubscribed = true; if (FPlatformProperties::IsGameOnly() || FPlatformProperties::IsServerOnly()) { bIsSubscribed = SteamApps()->BIsSubscribed(); } // Make sure the Steam user has valid access to the game if (bIsSubscribed) { UE_LOG_ONLINE(Log, TEXT("Steam User is subscribed %i"), bSteamworksClientInitialized); if (SteamUtils()) { SteamAppID = SteamUtils()->GetAppID(); SteamUtils()->SetWarningMessageHook(SteamworksWarningMessageHook); } } else { UE_LOG_ONLINE(Error, TEXT("Steam User is NOT subscribed, exiting.")); bSteamworksClientInitialized = false; FPlatformMisc::RequestExit(false); } } UE_LOG_ONLINE(Log, TEXT("[AppId: %d] Client API initialized %i"), GetSteamAppId(), bSteamworksClientInitialized); return bSteamworksClientInitialized; }