//-----------------------------------------------------------------------------
// 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;
}
