//-------------------------------------------------------------------------
bool CCryLobbySessionHandler::ShouldCallMapCommand( const char *pLevelName, const char *pGameRules )
{
	bool result = false;

	CGameLobby* pGameLobby = g_pGame->GetGameLobby();
	if (pGameLobby)
	{
		result = pGameLobby->ShouldCallMapCommand(pLevelName, pGameRules);
		if(result)
		{
			IPlatformOS* pPlatform = gEnv->pSystem->GetPlatformOS();

			SStreamingInstallProgress progress;
			pPlatform->QueryStreamingInstallProgressForLevel(pLevelName, &progress);
			const bool bLevelReady = SStreamingInstallProgress::eState_Completed == progress.m_state;
			if(!bLevelReady)
			{
				// we can jump directly into MP from system game invitation avoiding frontend, so update streaming install priorities here
				pPlatform->SwitchStreamingInstallPriorityToLevel(pLevelName);
				gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent( ESYSTEM_EVENT_LEVEL_NOT_READY, (UINT_PTR)pLevelName, 0 );
			}
			return bLevelReady;
		}
	}

	return result;
}
Exemplo n.º 2
0
bool CGameSessionHandler::ShouldCallMapCommand( const char *pLevelName, const char *pGameRules )
{
	IPlatformOS* pPlatform = gEnv->pSystem->GetPlatformOS();

	SStreamingInstallProgress progress;
	pPlatform->QueryStreamingInstallProgressForLevel(pLevelName, &progress);
	const bool bLevelReady = SStreamingInstallProgress::eState_Completed == progress.m_state;
	if(!bLevelReady)
	{
		gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent( ESYSTEM_EVENT_LEVEL_NOT_READY, (UINT_PTR)pLevelName, 0 );
	}
	return bLevelReady;
}
Exemplo n.º 3
0
//------------------------------------------------------------------------
bool CPlayerProfileImplConsole::LoginUser(SUserEntry* pEntry)
{
	// lookup stored profiles of the user (pEntry->userId) and fill in the pEntry->profileDesc
	// vector 
	pEntry->profileDesc.clear();

	IPlatformOS *os = gEnv->pSystem->GetPlatformOS();

	unsigned int userIndex;
	bool signedIn = os->UserIsSignedIn(pEntry->userId.c_str(), userIndex);
	CryLogAlways("LoginUser::UserIsSignedIn %d\n", signedIn);

	if (signedIn)
	{
		pEntry->profileDesc.push_back(SLocalProfileInfo(pEntry->userId));

		// Check the profile data exists - if not create it
		string path;
		InternalMakeFSPath(pEntry, pEntry->userId, path);
		IPlatformOS::IFileFinderPtr fileFinder = os->GetFileFinder(userIndex);
		//this assumes there is a profile if a directory exists
		if(!fileFinder->FileExists(path))
		{
			// Create new profile based on the defaults
			CPlayerProfile* profile = m_pMgr->GetDefaultCPlayerProfile();
			string name = profile->GetName();
			profile->SetName(pEntry->userId);
			m_pMgr->LoadGamerProfileDefaults(profile);
#if !CRY_PLATFORM_DURANGO
			// Durango: no reason to overwrite user profile with default profile, mainly for that we're always online.
			SaveProfile(pEntry, profile, pEntry->userId.c_str(), true);
#endif
			profile->SetName(name);
		}
	}
	else
	{
		printf( "OS No User signed in\n" );
	}

	return signedIn;
}
Exemplo n.º 4
0
	virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
	{
		switch (event)
		{
		case eFE_Initialize:
			{
			}
			break;
		case eFE_Activate:
#if CRY_PLATFORM_DURANGO

			if(IsPortActive(pActInfo, EIP_Poll))
			{
				// leaderboard
				IPlatformOS* pPlatformOS = GetISystem()->GetPlatformOS();
				int userIndex = pPlatformOS->GetFirstSignedInUser();
				auto user = Live::State::Manager::Instance().GetUserById( pPlatformOS->UserGetId(userIndex) );
				wstring leaderboardName(L"EnemiesDefeated");
				int startIndex = 0;
				int numEntries = 5;
				if ( user != nullptr )
				{

					user->RequestLeaderboardDataAsync(leaderboardName, startIndex, numEntries).then(
						[]( std::tuple<HRESULT, Live::LeaderboardData > result )
					{ 
						HRESULT hr = std::get<0>(result);
						if ( hr == S_OK )
						{
							Live::LeaderboardData data;
							data = std::get<1>(result);
							int breakhere = 0;
							CryLogAlways("got some data");
						}
					});
				}
			}
#endif
			break;
		}
	}
Exemplo n.º 5
0
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;
		}
	}
}
Exemplo n.º 6
0
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:
			{
				uint32 userIndex = g_pGame->GetExclusiveControllerDeviceIndex();

				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);
				int instance = gEnv->pSystem->GetApplicationInstance();
				if (instance>0)
				{
					size_t length = strlen(s_profileName);
					if (length + 3 < CRYLOBBY_USER_NAME_LENGTH)
					{
						s_profileName[length] = '(';
						s_profileName[length+1] = '0' + instance;
						s_profileName[length+2] = ')';
						s_profileName[length+3] = 0;
					}
				}

				requestedParams[a].m_pData = s_profileName;
			}
			break;

#if defined(PS3) || defined(ORBIS) || USE_STEAM
		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);

#if defined(PS3)
						if (g_pGame)
						{
							pConverter->m_sessionId = g_pGame->GetPendingRichPresenceSessionID();
						}
#endif
					}
					else
					{
						CryLog("[RichPresence] Failed to create rich presence string");
						pConverter->m_sizeOfStringBuffer = 0;
					}
				}
			}
			break;
#endif

#if defined(XENON)
		case CLCC_LIVE_TITLE_ID:
			requestedParams[a].m_32 = LIVE_TITLE_ID;
			break;
#endif//XENON

#if defined(PS3)
		case CLCC_PSN_COMMUNICATION_ID:
			requestedParams[a].m_pData = (void*)&s_communication_id;
			break;
		case CLCC_PSN_COMMUNICATION_PASSPHRASE:
			requestedParams[a].m_pData = (void*)&s_communication_passphrase;
			break;
		case CLCC_PSN_COMMUNICATION_SIGNATURE:
			requestedParams[a].m_pData = (void*)&s_communication_signature;
			break;
		case CLCC_PSN_CUSTOM_MENU_GAME_INVITE_STRING:
			GetXMBString("@xmb_invite_button", (SCryLobbyXMBString*)requestedParams[a].m_pData);			// <= SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX (max 21 chars + nul)	
			break;
		case CLCC_PSN_CUSTOM_MENU_GAME_JOIN_STRING:
			GetXMBString("@xmb_join_button", (SCryLobbyXMBString*)requestedParams[a].m_pData);				// <= SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX (max 21 chars + nul)	
			break;
		case CLCC_PSN_INVITE_SUBJECT_STRING:
			GetXMBString("@xmb_invite_sub", (SCryLobbyXMBString*)requestedParams[a].m_pData);					// < SCE_NP_BASIC_SUBJECT_CHARACTER_MAX (max 17 chars + nul)
			break;
		case CLCC_PSN_INVITE_BODY_STRING:
			GetXMBString("@xmb_invite_body", (SCryLobbyXMBString*)requestedParams[a].m_pData);				// < SCE_NP_BASIC_BODY_CHARACTER_MAX (max 511 chars + nul)																
			break;
		case CLCC_PSN_FRIEND_REQUEST_SUBJECT_STRING:
			GetXMBString("@xmb_friendrq_sub", (SCryLobbyXMBString*)requestedParams[a].m_pData);				// < SCE_NP_BASIC_SUBJECT_CHARACTER_MAX (max 17 chars + nul)																
			break;
		case CLCC_PSN_FRIEND_REQUEST_BODY_STRING:
			GetXMBString("@xmb_friendrq_body", (SCryLobbyXMBString*)requestedParams[a].m_pData);			// < SCE_NP_BASIC_BODY_CHARACTER_MAX	(max 511 chars + nul)																
			break;
		case CLCC_PSN_AGE_LIMIT:
			{
				SAgeData *pAgeData = (SAgeData*)requestedParams[a].m_pData;

				int userRegion = (pAgeData->countryCode[0] << 8) + pAgeData->countryCode[1];
				g_pGame->SetUserRegion(userRegion);

				if (strncmp(gPS3Env->sTitleID,"BLES",4)==0)
				{
					if (strncmp(pAgeData->countryCode,"de",2)==0)
					{
						// GERMANY
						requestedParams[a].m_32 = 18;
					}
					else if(strncmp(pAgeData->countryCode,"au",2)==0)
					{
						// AUSTRALIA
						requestedParams[a].m_32 = 15;
					}
					else
					{
						// EUROPE EXCLUDING GERMANY AND AUSTRALIA
						requestedParams[a].m_32 = 16;
					}
				}
				else
				{
					// US AND JAPAN (and any unknown).
					requestedParams[a].m_32 = 17;
				}
			}
			break;
		case CLCC_PSN_STORE_ID:
			if (strncmp(gPS3Env->sTitleID,"BLES",4)==0)
			{
				requestedParams[a].m_pData = (void*)s_sceeStore_id;
				break;
			}
			if (strncmp(gPS3Env->sTitleID,"BLUS",4)==0)
			{
				requestedParams[a].m_pData = (void*)s_sceaStore_id;
				break;
			}
			if (strncmp(gPS3Env->sTitleID,"BLJM",4)==0)
			{
				requestedParams[a].m_pData = (void*)s_scejStore_id;
				break;
			}
			requestedParams[a].m_pData = (void*)s_testStore_id;
			break;
		case CLCC_PSN_IS_DLC_INSTALLED:
			if (g_pGame && g_pGame->GetDLCManager() && g_pGame->GetDLCManager()->IsDLCLoaded(requestedParams[a].m_8))
			{
				requestedParams[a].m_8 = 1;
			}
			else
			{
				requestedParams[a].m_8 = 0;
			}
			break;
#endif//PS3

		case CLCC_CRYSTATS_ENCRYPTION_KEY:
			{
#if defined(XENON)
				requestedParams[a].m_pData = (void*)"";
#elif defined(PS3) || defined(ORBIS)
				requestedParams[a].m_pData = (void*)"";
#else
				requestedParams[a].m_pData = (void*)"";
#endif
			}
			break;

		case CLCC_MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH:
			requestedParams[a].m_8 = MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH;
			break;

#if USE_STEAM
#if !defined(RELEASE)
		case CLCC_STEAM_APPID:
			requestedParams[a].m_32 = STEAM_APPID;
			break;
#endif // !defined(RELEASE)
#endif // USE_STEAM

		default:
			CRY_ASSERT_MESSAGE(0,"Unknown Configuration Parameter Requested!");
			break;
		}
	}
}
Exemplo n.º 7
0
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:
			{
				uint32 userIndex = g_pGame->GetExclusiveControllerDeviceIndex();

				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);
				int instance = gEnv->pSystem->GetApplicationInstance();
				if (instance>0)
				{
					size_t length = strlen(s_profileName);
					if (length + 3 < CRYLOBBY_USER_NAME_LENGTH)
					{
						s_profileName[length] = '(';
						s_profileName[length+1] = '0' + instance;
						s_profileName[length+2] = ')';
						s_profileName[length+3] = 0;
					}
				}

				requestedParams[a].m_pData = s_profileName;
			}
			break;

#if defined(ORBIS)
		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 defined(DURANGO)
		case CLCC_LIVE_TITLE_ID:
			requestedParams[a].m_32 = DURANGO_LIVE_TITLE_ID;
			break;
		case CLCC_LIVE_SERVICE_CONFIG_ID:
			requestedParams[a].m_pData = DURANGO_LIVE_SERVICE_CONFIG_ID;
			break;
#endif//DURANGO

#if defined(ORBIS)
		case CLCC_PSN_TITLE_ID:
			requestedParams[a].m_pData = (void*)&s_title_id;
			break;

		case CLCC_PSN_TITLE_SECRET:
			requestedParams[a].m_pData = (void*)&s_title_secret;
			break;

		case CLCC_PSN_AGE_LIMIT:
			requestedParams[a].m_pData = (void*)&s_age_restrictions;
			break;

		case CLCC_PSN_PLUS_TEST_REQUIRED:
			requestedParams[a].m_32 = FALSE;
			break;

		case CLCC_PSN_CREATE_SESSION_ADVERTISEMENT:
			{
				SCryLobbySessionAdvertisement* pAdvertisement = (SCryLobbySessionAdvertisement*)requestedParams[a].m_pData;
				if (pAdvertisement)
				{
					pAdvertisement->m_numLanguages = s_NumLocalisedSessionAdvertisementLanguages;
					pAdvertisement->m_pLocalisedLanguages = (char**)s_LocalisedLanguages;
					pAdvertisement->m_pLocalisedSessionNames = (char**)s_LocalisedSessionAdvertisementName;
					pAdvertisement->m_pLocalisedSessionStatus = (char**)s_LocalisedSessionAdvertisementStatus;
					pAdvertisement->m_pJPGImage = (void*)s_SessionAdvertisementImage;
					pAdvertisement->m_sizeofJPGImage = strlen(s_SessionAdvertisementImage);
					// pAdvertisement->m_pData already points to a buffer of maximum size. It just needs to be filled in correctly.
					// pAdvertisement->m_sizeofData currently set to maximum size. You should change this to be correct size of actual data.
					// eg:	SAdvertDataStruct* pData = (SAdvertDataStruct*)pAdvertisement->m_pData;
					//			pData->id = 12345;
					//			pAdvertisement->m_sizeofData = sizeof(SAdvertDataStruct);
					uint32* pRealmId = (uint32*)pAdvertisement->m_pData;
					*pRealmId = 12345;
					pAdvertisement->m_sizeofData = sizeof(uint32);
				}
			}
			break;

		case CLCC_PSN_UPDATE_SESSION_ADVERTISEMENT:
			{
				SCryLobbySessionAdvertisement* pAdvertisement = (SCryLobbySessionAdvertisement*)requestedParams[a].m_pData;
				if (pAdvertisement)
				{
					// If pAdvertisement->m_numLanguages == 0, no attempt to alter the advertisement language settings will be made.
					// If pAdvertisement->m_numLanguages > 0, the previous language strings will all be overwritten with new ones.
					// (All strings are replaced or removed if not specified again)
					pAdvertisement->m_numLanguages = s_NumLocalisedSessionAdvertisementLanguages;
					pAdvertisement->m_pLocalisedLanguages = (char**)s_LocalisedLanguages;
					pAdvertisement->m_pLocalisedSessionNames = (char**)s_LocalisedSessionAdvertisementName;
					pAdvertisement->m_pLocalisedSessionStatus = (char**)s_LocalisedSessionAdvertisementStatus;
					// If pAdvertisement->m_pJPGImage is non-null and pAdvertisement->m_sizeofJPGImage > 0, the JPG data for the advertisement will be overwritten with a new JPG
					pAdvertisement->m_pJPGImage = (void*)s_SessionAdvertisementImage;
					pAdvertisement->m_sizeofJPGImage = strlen(s_SessionAdvertisementImage);
					// pAdvertisement->m_pData already points to a buffer containing a copy of the data passed into CryMatchmaking::SessionSetAdvertisementData.
					// and pAdvertisement->m_sizeofData is set to the correct size.
					// There should be no need to alter the contents of m_pData in this configuration callback.
				}
			}
			break;

		case CLCC_PSN_INVITE_BODY_STRING:
			{
				SCryLobbyXMBString* pStringData = (SCryLobbyXMBString*)requestedParams[a].m_pData;
				sprintf((char*)pStringData->m_pStringBuffer, "This is a test invite message");
				pStringData->m_sizeOfStringBuffer = strlen((char*)pStringData->m_pStringBuffer);
			}
			break;
#endif

		case CLCC_CRYSTATS_ENCRYPTION_KEY:
			{
#if defined(ORBIS)
				requestedParams[a].m_pData = (void*)"";
#else
				requestedParams[a].m_pData = (void*)"";
#endif
			}
			break;

		case CLCC_MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH:
			requestedParams[a].m_8 = MATCHMAKING_SESSION_PASSWORD_MAX_LENGTH;
			break;

#if USE_STEAM
#if !defined(RELEASE)
		case CLCC_STEAM_APPID:
			requestedParams[a].m_32 = STEAM_APPID;
			break;
#endif // !defined(RELEASE)
#endif // USE_STEAM

		default:
			CRY_ASSERT_MESSAGE(0,"Unknown Configuration Parameter Requested!");
			break;
		}
	}
}
Exemplo n.º 8
0
bool CCommonSaveGameHelper::GetSaveGames(CPlayerProfileManager::SUserEntry* pEntry, CPlayerProfileManager::TSaveGameInfoVec& outVec, const char* altProfileName="")
{
	// Scan savegames directory for XML files
	// we scan only for save game meta information
	string path;
	string profileName = (altProfileName && *altProfileName) ? altProfileName : pEntry->pCurrentProfile->GetName();
	m_pImpl->InternalMakeFSSaveGamePath(pEntry, profileName, path, true); 

	const bool bNeedProfilePrefix = m_pImpl->GetManager()->IsSaveGameFolderShared();
	string profilePrefix = profileName;
	profilePrefix+='_';
	size_t profilePrefixLen = profilePrefix.length();

	path.TrimRight("/\\");
	string search;
	search.Format("%s/*%s", path.c_str(), CRY_SAVEGAME_FILE_EXT);

	IPlatformOS* os = GetISystem()->GetPlatformOS();
	IPlatformOS::IFileFinderPtr fileFinder = os->GetFileFinder(IPlatformOS::Unknown_User);
	_finddata_t fd;
	intptr_t handle = fileFinder->FindFirst(search.c_str(), &fd);
	if (handle != -1)
	{
		CPlayerProfileManager::SSaveGameInfo sgInfo;
		do
		{
			if (strcmp(fd.name, ".") == 0 || strcmp(fd.name, "..") == 0)
				continue;

			if (bNeedProfilePrefix)
			{
				if (strnicmp(profilePrefix, fd.name, profilePrefixLen) != 0)
					continue;
			}

			sgInfo.name = fd.name;
			if (bNeedProfilePrefix) // skip profile_ prefix (we made sure this is valid by comparism above)
				sgInfo.humanName = fd.name+profilePrefixLen;
			else
				sgInfo.humanName = fd.name;
			PathUtil::RemoveExtension(sgInfo.humanName);
			sgInfo.description = "no description";

			bool ok = false;

			// filename construction
#if defined(PS3) || defined(XENON) //don't use meta files on PS3 or 360
			sgInfo.metaData.saveTime = static_cast<time_t>(fd.time_write); // the time gets used to find the most recent save
			sgInfo.metaData.loadTime = sgInfo.metaData.saveTime;
			ok = true;
#else
			string metaFilename = path;
			metaFilename.append("/");
			metaFilename.append(fd.name);
			metaFilename = PathUtil::ReplaceExtension(metaFilename, ".meta");
			XmlNodeRef rootNode = LoadXMLFile(metaFilename.c_str());
			// see if the root tag is o.k.
			if (rootNode && stricmp(rootNode->getTag(), "Metadata") == 0)
			{
				// get meta data
				ok = FetchMetaData(rootNode, sgInfo.metaData);
			}
			else
			{
				// when there is no meta information, we currently reject the savegame
				//ok = true; // un-comment this, if you want to accept savegames without meta
			}
			// Use the file modified time for the load time as we touch the saves when they are used to keep most recent checkpoint
			sgInfo.metaData.loadTime = static_cast<time_t>(fd.time_write);
#endif

			if (ok)
			{
				outVec.push_back(sgInfo);
			}
			else
			{
				GameWarning("CPlayerProfileImplFS::GetSaveGames: SaveGame '%s' of user '%s' is invalid", fd.name, pEntry->userId.c_str());
			}

		} while ( fileFinder->FindNext(handle, &fd) >= 0 );

		fileFinder->FindClose( handle );
	}

	return true;
}
Exemplo n.º 9
0
//------------------------------------------------------------------------
bool CPlayerProfileImplFSDir::LoginUser(SUserEntry* pEntry)
{
	// lookup stored profiles of the user (pEntry->userId) and fill in the pEntry->profileDesc
	// vector 
	pEntry->profileDesc.clear();

	// scan directory for profiles

	string path;
	InternalMakeFSPath(pEntry, "", path);  // no profile name -> only path

	std::multimap<time_t, SLocalProfileInfo> profiles;

	ICryPak * pCryPak = gEnv->pCryPak;
	_finddata_t fd;

	path.TrimRight("/\\");
	string search = path + "/*.*";

	IPlatformOS* pOS = GetISystem()->GetPlatformOS();
	IPlatformOS::IFileFinderPtr fileFinder = pOS->GetFileFinder(IPlatformOS::Unknown_User);
	intptr_t handle = fileFinder->FindFirst(search.c_str(), &fd);
	if (handle != -1)
	{
		do
		{
			if (strcmp(fd.name, ".") == 0 || strcmp(fd.name, "..") == 0)
				continue;

			if (fd.attrib & _A_SUBDIR)
			{
				// profile name = folder name
				// but make sure there is a profile.xml in it
				string filename = path + "/" + fd.name;
				filename += "/" ;
				filename += "profile.xml";
				XmlNodeRef rootNode = LoadXMLFile(filename.c_str());

				// see if the root tag is o.k.
				if (rootNode && stricmp(rootNode->getTag(), PROFILE_ROOT_TAG) == 0)
				{
					string profileName = fd.name;
					if (rootNode->haveAttr(PROFILE_NAME_TAG))
					{
						const char* profileHumanName = rootNode->getAttr(PROFILE_NAME_TAG);
						if (profileHumanName!=0 && stricmp(profileHumanName, profileName) == 0)
						{
							profileName = profileHumanName;
						}
					}
					time_t time = NULL;
					if (rootNode->haveAttr(PROFILE_LAST_PLAYED))
					{
						rootNode->getAttr(PROFILE_LAST_PLAYED, time);
					}
					SLocalProfileInfo info(profileName);
					info.SetLastLoginTime(time);
					profiles.insert(std::make_pair(time, info));
				}
				else
				{
					GameWarning("CPlayerProfileImplFSDir::LoginUser: Profile '%s' of User '%s' seems to exists but is invalid (File '%s). Skipped", fd.name, pEntry->userId.c_str(), filename.c_str());
				}
			}
		} while ( fileFinder->FindNext( handle, &fd ) >= 0 );

		fileFinder->FindClose( handle );
	}

	// Insert in most recently played order
	std::multimap<time_t, SLocalProfileInfo>::const_reverse_iterator itend = profiles.rend();
	for(std::multimap<time_t, SLocalProfileInfo>::const_reverse_iterator it = profiles.rbegin(); it != itend; ++it)
		pEntry->profileDesc.push_back(it->second);

	return true;
}