//-------------------------------------------------------------------------
ECryLobbyError CGameBrowser::StartSearchingForServers(SCrySessionSearchParam* param, CryMatchmakingSessionSearchCallback cb, void* cbArg, const bool bFavouriteIdSearch)
{
m_bFavouriteIdSearch = bFavouriteIdSearch;
m_delayedSearchType = eDST_None;
m_lastSearchTime = gEnv->pTimer->GetCurrTime();
#if defined(USE_SESSION_SEARCH_SIMULATOR)
if( m_pSessionSearchSimulator && gEnv->pConsole->GetCVar( "gl_searchSimulatorEnabled" )->GetIVal() )
{
const char* filepath = gEnv->pConsole->GetCVar( "gl_searchSimulatorFilepath" )->GetString();
if( filepath != NULL && strcmpi( filepath, m_pSessionSearchSimulator->GetCurrentFilepath() ) != 0 )
{
m_pSessionSearchSimulator->OpenSessionListXML( filepath );
}
m_pSessionSearchSimulator->OutputSessionListBlock( m_searchingTask, cb, cbArg );
return eCLE_Success;
}
else
#endif //defined(USE_SESSION_SEARCH_SIMULATOR)
{
ECryLobbyError error = eCLE_ServiceNotSupported;
ICryLobby *lobby = gEnv->pNetwork->GetLobby();
IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
uint32 userIndex = pPlayerProfileManager ? pPlayerProfileManager->GetExclusiveControllerDeviceIndex() : 0;
if(lobby)
{
CryLobbyTaskID previousTask = m_searchingTask;
error = lobby->GetLobbyService()->GetMatchMaking()->SessionSearch(userIndex, param, &m_searchingTask, cb, cbArg);
CryLog("CGameBrowser::StartSearchingForServers previousTask=%u, newTask=%u", previousTask, m_searchingTask);
}
return error;
}
}
XmlNodeRef CCheckpointSystem::ReadXML(const char *fileName)
{
IPlayerProfileManager *pPlayerProfMan = CCryAction::GetCryAction()->GetIPlayerProfileManager();;
string path;
if(!pPlayerProfMan)
{
//on consoles there is no profile manager
path = CONSOLE_SAVEGAME_DIRECTORY;
}
else
{
const char* sharedSaveGameFolder = pPlayerProfMan->GetSharedSaveGameFolder();
path = sharedSaveGameFolder;
}
path = PathUtil::AddSlash(path);
path.append(fileName);
//read XML data from given checkpoint file
_smart_ptr<IXmlParser> xmlParser;
xmlParser.reset(GetISystem()->GetXmlUtils()->CreateXmlParser());
XmlNodeRef data = xmlParser->ParseFile(path.c_str(), true);
if(!data)
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed reading checkpoint at %s", path.c_str());
return data;
}
void CCheckpointSystem::WriteXML(XmlNodeRef data, const char *fileName)
{
IPlayerProfileManager *pPlayerProfMan = CCryAction::GetCryAction()->GetIPlayerProfileManager();;
string path;
if(!pPlayerProfMan)
{
path = CONSOLE_SAVEGAME_DIRECTORY;
}
else
{
const char* sharedSaveGameFolder = pPlayerProfMan->GetSharedSaveGameFolder();
path = sharedSaveGameFolder;
}
path = PathUtil::AddSlash(path);
path.append(fileName);
if(data)
{
//write checkpoint data to xml file with given name
const string xmlHeader("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
bool bSuccess = data->saveToFile(path.c_str(), 32767/2, NULL);
if (bSuccess)
{
//remember last saved checkpoint for "quickload"
g_lastSavedCheckpoint = fileName;
}
else
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "Failed writing checkpoint file at %s", path.c_str());
}
}
void CProfileOptions::SaveProfile(unsigned int reason /* = ePR_Options*/)
{
IPlayerProfileManager* profileManager = g_pGame->GetIGameFramework()->GetIPlayerProfileManager();
if(!profileManager || profileManager->IsLoadingProfile() || profileManager->IsSavingProfile())
return;
IPlayerProfileManager::EProfileOperationResult result;
profileManager->SaveProfile(profileManager->GetCurrentUser(), result, reason);
}
IPlayerProfile* CUIManager::GetCurrentProfile()
{
if (!gEnv->pGame || !gEnv->pGame->GetIGameFramework() || !gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager())
{
assert(false);
return NULL;
}
IPlayerProfileManager* pProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
return pProfileManager->GetCurrentProfile( pProfileManager->GetCurrentUser() );
}
void CUISettings::OnLogoutUser()
{
CUIManager *pManager = CUIManager::GetInstance();
if(pManager)
pManager->SaveProfile();
if(gEnv->pGame && gEnv->pGame->GetIGameFramework() && gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager())
{
IPlayerProfileManager *pProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
pProfileManager->LogoutUser(pProfileManager->GetCurrentUser());
}
}
void CFlashMenuObject::SelectActiveProfile()
{
IPlayerProfileManager *pMan = g_pGame->GetOptions()->GetProfileManager();
if(!pMan) return;
const char *userName = pMan->GetCurrentUser();
for(int i = 0; i < pMan->GetProfileCount(userName); ++i )
{
IPlayerProfileManager::SProfileDescription profDesc;
pMan->GetProfileInfo(userName, i, profDesc);
const IPlayerProfile *preview = pMan->PreviewProfile(userName, profDesc.name);
int iActive = 0;
if(preview)
{
preview->GetAttribute("Activated",iActive);
}
if(iActive>0)
{
pMan->ActivateProfile(userName,profDesc.name);
break;
}
}
pMan->PreviewProfile(userName,NULL);
}
void CGameLobbyManager::ChatRestrictedCallback(UCryLobbyEventData eventData, void *arg)
{
SCryLobbyChatRestrictedData *pChatRestrictedData = eventData.pChatRestrictedData;
if(pChatRestrictedData)
{
CryLog("[GameLobbyManager] ChatRestrictedCallback user %d isChatRestricted %d", pChatRestrictedData->m_user, pChatRestrictedData->m_chatRestricted);
CGameLobbyManager *pGameLobbyManager = (CGameLobbyManager*)arg;
CRY_ASSERT(pGameLobbyManager);
IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
uint32 userIndex = pPlayerProfileManager ? pPlayerProfileManager->GetExclusiveControllerDeviceIndex() : 0;
if(pChatRestrictedData->m_user == userIndex)
{
pGameLobbyManager->m_isChatRestricted = pChatRestrictedData->m_chatRestricted;
}
}
}
//---------------------------------------
CGameServerLists::~CGameServerLists()
{
#if !defined(_RELEASE)
gEnv->pConsole->RemoveCommand("gsl_addFavourite");
gEnv->pConsole->RemoveCommand("gsl_removeFavourite");
gEnv->pConsole->RemoveCommand("gsl_listFavourite");
gEnv->pConsole->RemoveCommand("gsl_showFavourite");
gEnv->pConsole->RemoveCommand("gsl_addRecent");
gEnv->pConsole->RemoveCommand("gsl_removeRecent");
gEnv->pConsole->RemoveCommand("gsl_listRecent");
gEnv->pConsole->RemoveCommand("gsl_showRecent");
#endif
IPlayerProfileManager *pProfileMgr = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
if(pProfileMgr)
{
pProfileMgr->RemoveListener(this);
}
}
void CFlashMenuObject::UpdateProfiles()
{
IPlayerProfileManager *pProfileMan = g_pGame->GetOptions()->GetProfileManager();
if(!pProfileMan)
return;
m_pPlayerProfileManager = pProfileMan;
IPlayerProfileManager::EProfileOperationResult result;
m_pPlayerProfileManager->SaveProfile(m_pPlayerProfileManager->GetCurrentUser(), result);
if(m_apFlashMenuScreens[MENUSCREEN_FRONTENDSTART])
{
m_apFlashMenuScreens[MENUSCREEN_FRONTENDSTART]->Invoke("Root.MainMenu.Profile.resetProfiles");
const char *userName = m_pPlayerProfileManager->GetCurrentUser();
for(int i = 0; i < m_pPlayerProfileManager->GetProfileCount(userName); ++i )
{
IPlayerProfileManager::SProfileDescription profDesc;
pProfileMan->GetProfileInfo(userName, i, profDesc);
const IPlayerProfile *pProfile = m_pPlayerProfileManager->PreviewProfile(userName, profDesc.name);
string buffer;
if(pProfile && pProfile->GetAttribute("Singleplayer.LastSavedGame", buffer))
{
int pos = buffer.rfind('/');
if(pos)
buffer = buffer.substr(pos+1, buffer.length());
}
SFlashVarValue args[3] = {profDesc.name, buffer.c_str(), GetMappedProfileName(profDesc.name) };
m_apFlashMenuScreens[MENUSCREEN_FRONTENDSTART]->Invoke("Root.MainMenu.Profile.addProfileToList", args, 3);
}
m_pPlayerProfileManager->PreviewProfile(userName, NULL);
IPlayerProfile *pProfile = pProfileMan->GetCurrentProfile(userName);
if(pProfile)
m_apFlashMenuScreens[MENUSCREEN_FRONTENDSTART]->Invoke("setActiveProfile", GetMappedProfileName(pProfile->GetName()));
}
}
void CDLCManager::LoadDownloadableContent( uint32 userIdOveride /*= INVALID_CONTROLLER_INDEX*/ )
{
if( m_dlcLoaded || !m_bContentAvailable )
{
return;
}
const ICmdLineArg *pNoDLCArg = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "nodlc");
if (pNoDLCArg != NULL)
{
return;
}
// SECRET
uint8 keyData[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
// SECRET
uint32 userIndex;
if( userIdOveride != INVALID_CONTROLLER_INDEX )
{
userIndex = userIdOveride;
}
else
{
IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
userIndex = pPlayerProfileManager ? pPlayerProfileManager->GetExclusiveControllerDeviceIndex() : INVALID_CONTROLLER_INDEX;
}
if( userIndex != INVALID_CONTROLLER_INDEX )
{
gEnv->pSystem->GetPlatformOS()->MountDLCContent(this, userIndex, keyData);
m_dlcLoaded = true;
}
}
CGameServerLists::CGameServerLists()
{
Reset();
IPlayerProfileManager *pProfileMgr = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
if(pProfileMgr)
{
pProfileMgr->AddListener(this, true);
}
m_bHasChanges = false;
}
//Handles online state changes - when you sign out it returns you
void CGameLobbyManager::OnlineCallback(UCryLobbyEventData eventData, void *arg)
{
if (g_pGameCVars->g_ProcessOnlineCallbacks == 0)
return;
if(eventData.pOnlineStateData)
{
CGameLobbyManager *pLobbyManager = static_cast<CGameLobbyManager*>(arg);
CRY_ASSERT(eventData.pOnlineStateData->m_user < MAX_LOCAL_USERS);
pLobbyManager->m_onlineState[eventData.pOnlineStateData->m_user] = eventData.pOnlineStateData->m_curState;
IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
uint32 userIndex = pPlayerProfileManager ? pPlayerProfileManager->GetExclusiveControllerDeviceIndex() : 0;
#ifndef _RELEASE
const char *pEventType = "eOS_Unknown";
if (eventData.pOnlineStateData->m_curState == eOS_SignedOut)
{
pEventType = "eOS_SignedOut";
}
else if (eventData.pOnlineStateData->m_curState == eOS_SigningIn)
{
pEventType = "eOS_SigningIn";
}
else if (eventData.pOnlineStateData->m_curState == eOS_SignedIn)
{
pEventType = "eOS_SignedIn";
}
CryLog("[GameLobbyManager] OnlineCallback: eventType=%s, user=%u, currentUser=%u", pEventType, eventData.pOnlineStateData->m_user, userIndex);
ICryLobby *pLobby = gEnv->pNetwork->GetLobby();
if (g_pGameCVars->autotest_enabled && pLobby != NULL && (pLobby->GetLobbyServiceType() == eCLS_LAN))
{
// Don't care about signing out if we're in the autotester and in LAN mode
return;
}
#endif
{
EOnlineState onlineState = eventData.pOnlineStateData->m_curState;
if(onlineState == eOS_SignedOut)
{
if(eventData.pOnlineStateData->m_reason != eCLE_CyclingForInvite)
{
#ifdef USE_C2_FRONTEND
CFlashFrontEnd *pFlashFrontEnd = g_pGame->GetFlashMenu();
CMPMenuHub *pMPMenuHub = pFlashFrontEnd ? pFlashFrontEnd->GetMPMenu() : NULL;
if(pMPMenuHub)
{
#if INCLUDE_DEDICATED_LEADERBOARDS
pFlashFrontEnd->ClearDelaySessionLeave();
#endif
pMPMenuHub->OnlineStateChanged(eventData.pOnlineStateData->m_curState, eventData.pOnlineStateData->m_reason, eventData.pOnlineStateData->m_serviceConnected);
}
#endif //#ifdef USE_C2_FRONTEND
#if !defined(XENON) && !defined(PS3)
IPlayerProfileManager *pPPM = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
if(pPPM)
{
pPPM->ClearOnlineAttributes();
}
#endif
#ifdef GAME_IS_CRYSIS2
CWarningsManager *pWM = g_pGame->GetWarnings();
if(pWM)
{
pWM->RemoveWarning("ChatRestricted");
}
#endif
}
pLobbyManager->LeaveGameSession(eLSR_SignedOut);
}
}
}
}
EContextEstablishTaskResult OnStep(SContextEstablishState& state)
{
IActionMapManager *pActionMapMan = CCryAction::GetCryAction()->GetIActionMapManager();
CRY_ASSERT(pActionMapMan);
IActionMap* pDefaultActionMap = NULL;
IActionMap* pDebugActionMap = NULL;
IActionMap* pPlayerActionMap = NULL;
IActionMap* pPlayerGamemodeActionMap = NULL;
const char* disableGamemodeActionMapName = "player_mp";
const char* gamemodeActionMapName = "player_sp";
if(gEnv->bMultiplayer)
{
disableGamemodeActionMapName = "player_sp";
gamemodeActionMapName = "player_mp";
}
if (true)
{
IPlayerProfileManager* pPPMgr = CCryAction::GetCryAction()->GetIPlayerProfileManager();
if (pPPMgr)
{
int userCount = pPPMgr->GetUserCount();
IPlayerProfile* pProfile = NULL;
const char* userId = "UNKNOWN";
if (userCount == 0)
{
if (gEnv->pSystem->IsDevMode())
{
#ifndef _RELEASE
//In devmode and not release get the default user if no users are signed in e.g. autotesting, map on the command line
pProfile = pPPMgr->GetDefaultProfile();
if (pProfile)
{
userId = pProfile->GetUserId();
}
#endif // #ifndef _RELEASE
}
else
{
CryFatalError("[PlayerProfiles] CGameContext::StartGame: No users logged in");
return eCETR_Failed;
}
}
if (userCount > 0)
{
IPlayerProfileManager::SUserInfo info;
pPPMgr->GetUserInfo(0, info);
pProfile = pPPMgr->GetCurrentProfile(info.userId);
userId = info.userId;
}
if (pProfile)
{
pDefaultActionMap = pProfile->GetActionMap("default");
pDebugActionMap = pProfile->GetActionMap("debug");
pPlayerActionMap = pProfile->GetActionMap("player");
if (pDefaultActionMap == 0 && pPlayerActionMap == 0)
{
CryFatalError("[PlayerProfiles] CGameContext::StartGame: User '%s' has no actionmap 'default'!", userId);
return eCETR_Failed;
}
}
else
{
CryFatalError("[PlayerProfiles] CGameContext::StartGame: User '%s' has no active profile!", userId);
return eCETR_Failed;
}
}
else
{
CryFatalError("[PlayerProfiles] CGameContext::StartGame: No player profile manager!");
return eCETR_Failed;
}
}
if (pDefaultActionMap == 0 )
{
// use action map without any profile stuff
pActionMapMan->EnableActionMap( "default", true );
pDefaultActionMap = pActionMapMan->GetActionMap("default");
CRY_ASSERT_MESSAGE(pDefaultActionMap, "'default' action map not found!");
}
if (pDebugActionMap == 0 )
{
// use action map without any profile stuff
pActionMapMan->EnableActionMap( "debug", true );
pDebugActionMap = pActionMapMan->GetActionMap("debug");
}
if (pPlayerActionMap == 0)
{
pActionMapMan->EnableActionMap( "player", true );
pPlayerActionMap = pActionMapMan->GetActionMap("player");
}
if (!pDefaultActionMap)
return eCETR_Failed;
EntityId actorId = GetListener();
if (!actorId)
return eCETR_Wait;
if(pDefaultActionMap)
{
pDefaultActionMap->SetActionListener( actorId );
}
if(pDebugActionMap)
{
pDebugActionMap->SetActionListener( actorId );
}
if(pPlayerActionMap)
{
pPlayerActionMap->SetActionListener( actorId );
}
pActionMapMan->EnableActionMap(disableGamemodeActionMapName, false);
pActionMapMan->EnableActionMap(gamemodeActionMapName, true);
pPlayerGamemodeActionMap = pActionMapMan->GetActionMap(gamemodeActionMapName);
if(pPlayerGamemodeActionMap)
{
pPlayerGamemodeActionMap->SetActionListener(actorId);
}
// TODO: callback to game code for game specific action maps
{
IActionMap* crysis2_common = pActionMapMan->GetActionMap("crysis2_common");
if (crysis2_common != NULL)
crysis2_common->SetActionListener( actorId );
IActionMap* crysis2_suitmenu_opened = pActionMapMan->GetActionMap("crysis2_suitmenu_opened");
if (crysis2_suitmenu_opened != NULL)
crysis2_suitmenu_opened->SetActionListener( actorId );
IActionMap* crysis2_suitmenu_closed = pActionMapMan->GetActionMap("crysis2_suitmenu_closed");
if (crysis2_suitmenu_closed != NULL)
crysis2_suitmenu_closed->SetActionListener( actorId );
IActionMap* player_cine = pActionMapMan->GetActionMap("player_cine");
if (player_cine != NULL)
player_cine->SetActionListener( actorId );
IActionMap* booss_duell = pActionMapMan->GetActionMap("boss_duell");
if (booss_duell != NULL)
booss_duell->SetActionListener( actorId );
}
CCryAction::GetCryAction()->GetIActionMapManager()->Enable(true);
return eCETR_Ok;
}
void CGameBrowser::ConfigurationCallback(ECryLobbyService service, SConfigurationParams *requestedParams, uint32 paramCount)
{
uint32 a;
for (a=0;a<paramCount;a++)
{
switch (requestedParams[a].m_fourCCID)
{
case CLCC_LAN_USER_NAME:
{
IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager();
uint32 userIndex = pPlayerProfileManager ? pPlayerProfileManager->GetExclusiveControllerDeviceIndex() : 0;
IPlatformOS *pPlatformOS = gEnv->pSystem->GetPlatformOS();
IPlatformOS::TUserName tUserName = "";
if(pPlatformOS)
{
pPlatformOS->UserGetName(userIndex, tUserName);
}
// this will null terminate for us if necessary
cry_strncpy(s_profileName, tUserName.c_str(), CRYLOBBY_USER_NAME_LENGTH);
requestedParams[a].m_pData = s_profileName;
}
break;
#if defined(PS3) || USE_CRYLOBBY_GAMESPY
case CLCC_CRYLOBBY_PRESENCE_CONVERTER:
{
SCryLobbyPresenceConverter* pConverter = (SCryLobbyPresenceConverter*)requestedParams[a].m_pData;
if (pConverter)
{
//-- Use the pConverter->m_numData data items in pConverter->m_pData to create a string in pConverter->m_pStringBuffer
//-- Use the initial value of pConverter->sizeOfStringBuffer as a maximum string length allowed, but
//-- update pConverter->sizeOfStringBuffer to the correct length when the string is filled in.
//-- Set pConverter->sizeOfStringBuffer = 0 to invalidate bad data so it isn't sent to PSN.
CryFixedStringT<MAX_PRESENCE_STRING_SIZE> strPresence;
if(CreatePresenceString(strPresence, pConverter->m_pData, pConverter->m_numData))
{
CryLog("[RichPresence] Succeeded %s", strPresence.c_str());
sprintf((char*)pConverter->m_pStringBuffer, "%s", strPresence.c_str());
pConverter->m_sizeOfStringBuffer = strlen((char*)pConverter->m_pStringBuffer);
}
else
{
CryLog("[RichPresence] Failed to create rich presence string");
pConverter->m_sizeOfStringBuffer = 0;
}
}
}
break;
#endif
#if USE_CRYLOBBY_GAMESPY
// The following GameSpy data are always available.
case CLCC_GAMESPY_TITLE:
requestedParams[ a ].m_pData = ObfuscateGameSpyTitle();
break;
case CLCC_GAMESPY_SECRETKEY:
requestedParams[ a ].m_pData = ObfuscateGameSpySecretKey();
break;
case CLCC_GAMESPY_GAMEVERSION:
requestedParams[ a ].m_32 = GameLobbyData::GetVersion();
break;
case CLCC_GAMESPY_GAMEVERSIONSTRING:
requestedParams[ a ].m_pData = ( void* )GAMESPY_GAMEVERSIONSTRING;
break;
case CLCC_GAMESPY_DISTRIBUTIONID:
requestedParams[ a ].m_32 = GAMESPY_DISTRIBUTIONID;
break;
case CLCC_GAMESPY_PRODUCTID:
requestedParams[ a ].m_32 = GAMESPY_PRODUCTID;
break;
case CLCC_GAMESPY_GAMEID:
requestedParams[ a ].m_32 = GAMESPY_GAMEID;
break;
case CLCC_GAMESPY_NAMESPACEID:
requestedParams[ a ].m_32 = GAMESPY_NAMESPACEID;
break;
case CLCC_GAMESPY_PARTNERID:
requestedParams[ a ].m_32 = GAMESPY_PARTNERID;
break;
case CLCC_GAMESPY_REQUIREDNICK:
requestedParams[ a ].m_pData = GAMESPY_REQUIREDNICK;
break;
case CLCC_GAMESPY_D2GCATALOGREGION:
if ( g_pGameCVars )
{
requestedParams[a].m_pData = ( void* )g_pGameCVars->g_gamespy_catalog_region;
}
else
{
requestedParams[a].m_pData = NULL;
}
break;
case CLCC_GAMESPY_D2GCATALOGVERSION:
if ( g_pGameCVars )
{
requestedParams[a].m_32 = g_pGameCVars->g_gamespy_catalog_version->GetIVal();
}
else
{
requestedParams[a].m_32 = 0;
}
break;
case CLCC_GAMESPY_D2GCATALOGTOKEN:
if ( g_pGameCVars )
{
requestedParams[a].m_pData = ( void* )g_pGameCVars->g_gamespy_catalog_token;
}
else
{
requestedParams[a].m_pData = 0;
}
break;
// CLCC_CRYLOBBY_LOGINGUISTATE is common to all online services for
// which login is not handled by the OS. It will be requested if any
// other requested data may require a login GUI to be displayed.
case CLCC_CRYLOBBY_LOGINGUISTATE:
//CRY_TODO( 30, 4, 2010, "Display a real GUI, don't use these hard coded values" );
if ( g_pGameCVars )
{
ECryLobbyLoginGUIState requestedGUIState = eCLLGS_ExistingAccount;//eCLLGS_NotFinished;
if(gEnv->IsDedicated() || g_pGameCVars->g_gamespy_loginUI==0)
{
requestedGUIState = eCLLGS_ExistingAccount;
}
else if(g_pGame->GetGameBrowser())
{
// requestedGUIState = g_pGame->GetGameBrowser()->GetLoginGUIState();
}
requestedParams[ a ].m_32 = requestedGUIState;
}
else
{
requestedParams[ a ].m_32 = eCLLGS_Cancelled;
}
break;
case CLCC_CRYLOBBY_LOGINGUICOUNT:
if ( g_pGameCVars )
{
requestedParams[ a ].m_32 = 0;//g_pGameCVars->g_gamespy_loginCount;
}
else
{
requestedParams[ a ].m_32 = 0;
}
break;
// The following GameSpy data may require a login GUI to be displayed.
case CLCC_GAMESPY_EMAIL:
if ( g_pGameCVars )
{
string email = "crysis2.";
email.append(g_pGameCVars->g_gamespy_accountnumber->GetString());
email.append("*****@*****.**");
requestedParams[a].m_pData = (void*)email.c_str();//(void*)g_pGameCVars->g_gamespy_email->GetString();
}
else
{
requestedParams[a].m_pData = NULL;
}
break;
case CLCC_GAMESPY_UNIQUENICK:
if ( g_pGameCVars )
{
string nick = "crysis2_";
nick.append(g_pGameCVars->g_gamespy_accountnumber->GetString());
nick.append("_paulm");
requestedParams[a].m_pData = (void*)nick.c_str();//(void*)g_pGameCVars->g_gamespy_unique_nick->GetString();
}
else
{
requestedParams[a].m_pData = NULL;
}
break;
case CLCC_GAMESPY_PASSWORD:
if ( g_pGameCVars )
{
requestedParams[a].m_pData = "upple?9!";//(void*)g_pGameCVars->g_gamespy_password->GetString();
}
else
{
requestedParams[a].m_pData = NULL;
}
break;
case CLCC_GAMESPY_CDKEY:
if ( g_pGameCVars )
{
requestedParams[a].m_pData = (void*)g_pGameCVars->g_gamespy_cdkey->GetString();
}
else
{
requestedParams[a].m_pData = NULL;
}
break;
case CLCC_GAMESPY_KEYNAME:
// Session user data IDs map to GameSpy keys, which must be named.
// CLCC_GAMESPY_KEYNAME will be requested for each session user data ID
// greater than or equal to NUM_RESERVED_KEYS.
//
// IN: requestedParams[ a ].m_8 holds a session user data ID.
// OUT: requestedParams[ a ].m_pData holds the GameSpy key name.
//
// NOTE: m_8 and m_pData are members of a union, so setting m_pData
// will overwrite m_8.
switch ( requestedParams[ a ].m_8 )
{
case LID_MATCHDATA_GAMEMODE:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_GAMEMODE;
break;
case LID_MATCHDATA_MAP:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_MAP;
break;
case LID_MATCHDATA_ACTIVE:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_ACTIVE;
break;
case LID_MATCHDATA_VERSION:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_VERSION;
break;
case LID_MATCHDATA_REQUIRED_DLCS:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_REQUIRED_DLCS;
break;
case LID_MATCHDATA_PLAYLIST:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_PLAYLIST;
break;
case LID_MATCHDATA_LANGUAGE:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_LANGUAGE;
break;
case LID_MATCHDATA_OFFICIAL:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_OFFICIAL;
break;
case LID_MATCHDATA_FAVOURITE_ID:
requestedParams[ a ].m_pData = GAMESPY_KEYNAME_MATCHDATA_FAVOURITE_ID;
break;
default:
CRY_ASSERT_MESSAGE( 0, "Session user data ID has no GameSpy key name" );
requestedParams[ a ].m_pData = NULL;
break;
}
break;
case CLCC_GAMESPY_KEYSTRINGVALUE:
{
SCryLobbyUserDataStringParam* pParam = static_cast< SCryLobbyUserDataStringParam* >( requestedParams[ a ].m_pData );
switch ( pParam->id )
{
case LID_MATCHDATA_MAP:
requestedParams[ a ].m_pData = const_cast< void* >( static_cast< const void* >( GameLobbyData::GetMapFromHash( pParam->value ) ) );
break;
case LID_MATCHDATA_GAMEMODE:
requestedParams[ a ].m_pData = const_cast< void* >( static_cast< const void* >( GameLobbyData::GetGameRulesFromHash( pParam->value ) ) );
break;
default:
requestedParams[ a ].m_pData = NULL;
break;
}
}
break;
case CLCC_GAMESPY_P2PLEADERBOARDFMT:
requestedParams[a].m_pData = ( void* )GAMESPY_P2P_LEADERBOARD_FORMAT;
break;
case CLCC_GAMESPY_DEDICATEDLEADERBOARDFMT:
requestedParams[a].m_pData = ( void* )GAMESPY_DEDICATED_LEADERBOARD_FORMAT;
break;
case CLCC_GAMESPY_P2PSTATSTABLE:
requestedParams[a].m_pData = ( void* )GAMESPY_P2P_STATS_TABLE;
break;
case CLCC_GAMESPY_DEDICATEDSTATSTABLE:
requestedParams[a].m_pData = ( void* )GAMESPY_DEDICATED_STATS_TABLE;
break;
case CLCC_GAMESPY_TITLECDKEYSERVER:
requestedParams[a].m_32 = 1;
break;
#if defined( DEDICATED_SERVER )
case CLCC_GAMESPY_DEDIVERSION:
requestedParams[a].m_32 = GAMESPY_DEDI_VERSION;
break;
#endif
#if USE_CRYLOBBY_GAMESPY_VOIP
case CLCC_GAMESPY_VOICE_CODEC:
requestedParams[a].m_pData = (void*)CCryGameSpyVoiceCodec::Initialise();
break;
#endif // USE_CRYLOBBY_GAMESPY_VOIP
#endif // USE_CRYLOBBY_GAMESPY
case CLCC_MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH:
requestedParams[a].m_8 = MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH;
break;
default:
CRY_ASSERT_MESSAGE(0,"Unknown Configuration Parameter Requested!");
break;
}
}
}
//Handles online state changes - when you sign out it returns you
void CGameLobbyManager::OnlineCallback(UCryLobbyEventData eventData, void *arg)
{
if (g_pGameCVars->g_ProcessOnlineCallbacks == 0)
return;
if(eventData.pOnlineStateData)
{
CGameLobbyManager *pLobbyManager = static_cast<CGameLobbyManager*>(arg);
#if defined(DEDICATED_SERVER)
EOnlineState previousState = pLobbyManager->m_onlineState[eventData.pOnlineStateData->m_user];
#endif
CRY_ASSERT(eventData.pOnlineStateData->m_user < MAX_LOCAL_USERS);
pLobbyManager->m_onlineState[eventData.pOnlineStateData->m_user] = eventData.pOnlineStateData->m_curState;
uint32 userIndex = g_pGame->GetExclusiveControllerDeviceIndex();
ICryLobby *pLobby = FakeGetLobby();
#ifndef _RELEASE
const char *pEventType = "eOS_Unknown";
if (eventData.pOnlineStateData->m_curState == eOS_SignedOut)
{
pEventType = "eOS_SignedOut";
}
else if (eventData.pOnlineStateData->m_curState == eOS_SigningIn)
{
pEventType = "eOS_SigningIn";
}
else if (eventData.pOnlineStateData->m_curState == eOS_SignedIn)
{
pEventType = "eOS_SignedIn";
}
CryLog("[GameLobbyManager] OnlineCallback: eventType=%s, user=%u, currentUser=%u", pEventType, eventData.pOnlineStateData->m_user, userIndex);
if (g_pGameCVars->autotest_enabled && pLobby != NULL && (pLobby->GetLobbyServiceType() == eCLS_LAN))
{
// Don't care about signing out if we're in the autotester and in LAN mode
return;
}
#endif
{
EOnlineState onlineState = eventData.pOnlineStateData->m_curState;
if(onlineState == eOS_SignedOut)
{
if(pLobby && pLobby->GetLobbyServiceType() == eCLS_Online)
{
if(eventData.pOnlineStateData->m_reason != eCLE_CyclingForInvite)
{
CErrorHandling *pErrorHandling = CErrorHandling::GetInstance();
if (pErrorHandling)
{
pErrorHandling->OnFatalError(CErrorHandling::eFE_PlatformServiceSignedOut);
}
else
{
pLobbyManager->LeaveGameSession(eLSR_SignedOut);
}
IPlayerProfileManager *pPPM = g_pGame->GetIGameFramework()->GetIPlayerProfileManager();
if(pPPM)
{
pPPM->ClearOnlineAttributes();
}
#if 0 // old frontend
CWarningsManager *pWM = g_pGame->GetWarnings();
if(pWM)
{
pWM->RemoveWarning("ChatRestricted");
}
#endif
}
#if defined(DEDICATED_SERVER)
if (previousState != eOS_SignedOut)
{
CryLogAlways("We've been signed out, reason=%u, bailing", eventData.pOnlineStateData->m_reason);
gEnv->pConsole->ExecuteString("quit", false, true);
}
#endif
}
}
}
}
}
