void CDLCManager::OnDLCRemoved(const char* sDLCRootFolder) { //clear all the data for( int iDLC = 0; iDLC < MAX_DLC_COUNT; iDLC++ ) { if( IsDLCLoaded( iDLC ) ) { if( strcmpi( m_dlcContents[iDLC].root.c_str(), sDLCRootFolder ) == 0 ) { m_loadedDLCs &= ~BIT(iDLC); m_allowedDLCs &= ~BIT(iDLC); //close the paks CryFixedStringT<ICryPak::g_nMaxPath> path; path.Format("%s/dlcLevelExtras.pak", sDLCRootFolder); CryLog( "DLC: Closing %s", path.c_str() ); gEnv->pCryPak->ClosePack( path.c_str() ); path.Format("%s/dlcData.pak", sDLCRootFolder); CryLog( "DLC: Closing %s", path.c_str() ); gEnv->pCryPak->ClosePack( path.c_str() ); } } } }
void COptionsManager::SystemConfigChanged(bool silent) { //gEnv->pConsole->ExecuteString("sys_SaveCVars 1"); //gEnv->pSystem->SaveConfiguration(); //gEnv->pConsole->ExecuteString("sys_SaveCVars 0"); if(m_pPlayerProfileManager) { UpdateToProfile(); SaveProfile(); } if(!silent) { if(CFlashMenuScreen *pCurrentMenu = GetCurrentMenu()) { pCurrentMenu->Invoke("showErrorMessage", "Box1"); CryFixedStringT<128> text = "@system_spec_"; text.append(gEnv->pConsole->GetCVar("sys_spec")->GetString()); pCurrentMenu->Invoke("setErrorText", text.c_str()); text = "sys_spec_Full \0"; text.append(gEnv->pConsole->GetCVar("sys_spec")->GetString()); gEnv->pConsole->ExecuteString(text.c_str()); } } UpdateFlashOptions(); }
void CAntiCheatManager::ParseAntiCheatConfig(const char * filename) { CCryFile file; CryFixedStringT<128> realFileName; realFileName.Format("%s/%s", PathUtil::GetGameFolder().c_str(), filename); if (file.Open( realFileName.c_str(), "rb", ICryPak::FOPEN_HINT_QUIET | ICryPak::FOPEN_ONDISK )) { const size_t fileSize = file.GetLength(); char* pBuffer = new char [fileSize]; file.ReadRaw(pBuffer, fileSize); XmlNodeRef xmlData = gEnv->pSystem->LoadXmlFromBuffer(pBuffer, fileSize); SAFE_DELETE_ARRAY(pBuffer); if(xmlData) { CryLog("Parsing Anti-Cheat Configuration..."); ParseAntiCheatConfig(xmlData); } else { CryLog("Unable to parse Anti-Cheat Configuration"); } } else { CryLog("Unable to load '%s'", realFileName.c_str()); } }
void CSmartMine::FullSerialize( TSerialize ser ) { uint32 targetCount = m_trackedEntities.size(); ser.Value( "MineEnabled", m_enabled ); ser.Value( "MineFaction", m_factionId ); ser.Value( "MineTargetCount", targetCount ); CryFixedStringT<16> targetName; if (ser.IsReading()) { m_trackedEntities.clear(); for(uint32 i = 0; i < targetCount; ++i) { m_trackedEntities.push_back(); targetName.Format( "MineTarget_%d", i ); ser.Value( targetName.c_str(), m_trackedEntities[i] ); } } else { for(uint32 i = 0; i < targetCount; ++i) { targetName.Format( "MineTarget_%d", i ); ser.Value( targetName.c_str(), m_trackedEntities[i] ); } } StateMachineSerializeBehavior( SStateEventSerialize( ser ) ); }
int CGameStartup::Run(const char* autoStartLevelName) { gEnv->pConsole->ExecuteString("exec autoexec.cfg"); if (autoStartLevelName) { //load savegame if(CryStringUtils::stristr(autoStartLevelName, CRY_SAVEGAME_FILE_EXT) != 0) { CryFixedStringT<256> fileName (autoStartLevelName); // NOTE! two step trimming is intended! fileName.Trim(" "); // first: remove enclosing spaces (outside ") fileName.Trim("\""); // second: remove potential enclosing " gEnv->pGame->GetIGameFramework()->LoadGame(fileName.c_str()); } else //start specified level { CryFixedStringT<256> mapCmd ("map "); mapCmd+=autoStartLevelName; gEnv->pConsole->ExecuteString(mapCmd.c_str()); } } else { gEnv->pConsole->ExecuteString("map example"); } #if CRY_PLATFORM_WINDOWS if (!(gEnv && gEnv->pSystem) || (!gEnv->IsEditor() && !gEnv->IsDedicated())) { ::ShowCursor(FALSE); if (GetISystem()->GetIHardwareMouse()) GetISystem()->GetIHardwareMouse()->DecrementCounter(); } #else if (gEnv && gEnv->pHardwareMouse) gEnv->pHardwareMouse->DecrementCounter(); #endif #if !CRY_PLATFORM_DURANGO for(;;) { if (!Update(true, 0)) { break; } } #endif return 0; }
bool CModInfoManager::LoadMod(const char* modName) { CryFixedStringT<256> command; command.Format("g_loadMod %s", modName); gEnv->pConsole->ExecuteString(command.c_str()); return true; }
void CCheckpointSystem::WriteMetaData(EntityId checkpointId, XmlNodeRef parentNode, SCheckpointData &outMetaData) { XmlNodeRef node = GetISystem()->CreateXmlNode(META_DATA_SECTION); const char *levelName = CCryAction::GetCryAction()->GetLevelName(); CRY_ASSERT(levelName); CryFixedStringT<32> curlevelName = levelName; RepairLevelName(curlevelName); node->setAttr("Version", CHECKPOINT_VERSION_NUMBER); node->setAttr("LevelName", curlevelName.c_str()); node->setAttr("CheckpointId", checkpointId); //write checkpoint name to be independent of entityId IEntity *pCheckpointEntity = gEnv->pEntitySystem->GetEntity(checkpointId); if(pCheckpointEntity) node->setAttr("CheckpointName", pCheckpointEntity->GetName()); else node->setAttr("CheckpointName", "none"); string timeString; GameUtils::timeToString(time(NULL), timeString); node->setAttr("Timestamp", timeString.c_str()); parentNode->addChild(node); //write back metadata for listeners outMetaData.m_checkPointId = checkpointId; outMetaData.m_levelName = levelName; outMetaData.m_saveTime = timeString.c_str(); }
//------------------------------------------------------------------------ int CScriptBind_Item::GetUsableText(IFunctionHandler *pH) { CItem *pItem = GetItem(pH); if (!pItem) return pH->EndFunction(); CryFixedWStringT<64> localizedString; CryFixedStringT<64> finalString; CryFixedStringT<64> tempString; tempString.Format("@ui_item_pickup %s", pItem->GetSharedItemParams()->params.display_name.c_str()); localizedString = CHUDUtils::LocalizeStringW(tempString.c_str()); finalString.Format("%ls", localizedString.c_str()); return pH->EndFunction(finalString.c_str()); }
void CView::CreateAudioListener() { if (m_pAudioListener == NULL) { SEntitySpawnParams oEntitySpawnParams; oEntitySpawnParams.sName = "SoundListener"; oEntitySpawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("SoundListener"); m_pAudioListener = gEnv->pEntitySystem->SpawnEntity(oEntitySpawnParams, true); if (m_pAudioListener != NULL) { m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER); gEnv->pEntitySystem->AddEntityEventListener(m_pAudioListener->GetId(), ENTITY_EVENT_DONE, this); CryFixedStringT<64> sTemp; sTemp.Format("SoundListener(%d)", static_cast<int>(m_pAudioListener->GetId())); m_pAudioListener->SetName(sTemp.c_str()); IEntityAudioProxyPtr pIEntityAudioProxy = crycomponent_cast<IEntityAudioProxyPtr>(m_pAudioListener->CreateProxy(ENTITY_PROXY_AUDIO)); CRY_ASSERT(pIEntityAudioProxy.get()); } else { CryFatalError("<Sound>: audio listener creation failed in CView ctor!"); } } }
int DesignerWarningFunc(const char * message) { if (g_pGameCVars->designer_warning_enabled && (!gEnv->IsDedicated())) { GameWarning("!DESIGNER WARNING\n%s", message); } // kept because autotests gather all designer warnings out of logs with this form CryLogAlways("---DESIGNER_WARNING: %s", message); CryLogAlways("----------------------------------------"); #if ENABLE_FEATURE_TESTER // If feature testing is in progress, write each designer warning out as a failed feature test CFeatureTester * featureTester = CFeatureTester::GetInstance(); if (featureTester) { CAutoTester * autoTestResultWriter = featureTester->GetAutoTesterIfActive(); if (autoTestResultWriter) { CryFixedStringT<32> warningName; warningName.Format("DesignerWarning%04u", s_numDesignerWarningsHit); autoTestResultWriter->AddSimpleTestCase("DesignerWarnings", warningName.c_str(), 0.1f, message); } } #endif s_numDesignerWarningsHit++; return 0; }
void CView::CreateAudioListener() { if (m_pAudioListener == nullptr) { SEntitySpawnParams oEntitySpawnParams; oEntitySpawnParams.sName = "AudioListener"; oEntitySpawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("AudioListener"); m_pAudioListener = gEnv->pEntitySystem->SpawnEntity(oEntitySpawnParams, true); if (m_pAudioListener != nullptr) { // We don't want the audio listener to serialize as the entity gets completely removed and recreated during save/load! m_pAudioListener->SetFlags(m_pAudioListener->GetFlags() | (ENTITY_FLAG_TRIGGER_AREAS | ENTITY_FLAG_NO_SAVE)); m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER); gEnv->pEntitySystem->AddEntityEventListener(m_pAudioListener->GetId(), ENTITY_EVENT_DONE, this); CryFixedStringT<64> sTemp; sTemp.Format("AudioListener(%d)", static_cast<int>(m_pAudioListener->GetId())); m_pAudioListener->SetName(sTemp.c_str()); IEntityAudioProxyPtr pIEntityAudioProxy = crycomponent_cast<IEntityAudioProxyPtr>(m_pAudioListener->CreateProxy(ENTITY_PROXY_AUDIO)); CRY_ASSERT(pIEntityAudioProxy.get()); } else { CryFatalError("<Audio>: Audio listener creation failed in CView::CreateAudioListener!"); } } else { m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER); m_pAudioListener->InvalidateTM(ENTITY_XFORM_POS); } }
void CRevertibleConfigLoader::RevertCVarChanges() { if (!m_savedCVars.empty()) { CryLog ("Need to undo %" PRISIZE_T " %s...", m_savedCVars.size(), (m_savedCVars.size() == 1) ? "variable" : "variables"); IConsole * pConsole = gEnv->pConsole; CryFixedStringT<128> cmd; //Revert the saved cvars in reverse order to handle duplicate settings of the same cvar (which shouldn't be done but people ignore warnings) for (int n = m_savedCVars.size()-1; n >= 0; --n) { ICVar * var = gEnv->pConsole->GetCVar(m_savedCVars[n].m_name); if (var && var->GetType() == CVAR_STRING && strlen(m_savedCVars[n].m_value) == 0) { var->Set(m_savedCVars[n].m_value); } else { cmd.Format("%s %s", m_savedCVars[n].m_name, m_savedCVars[n].m_value); } pConsole->ExecuteString(cmd.c_str(), true); } m_cvarsTextBlock.EmptyWithoutFreeing(); m_savedCVars.clear(); } }
char const* const CAudioSystemImpl_sdlmixer::GetAudioFileLocation(SATLAudioFileEntryInfo* const pFileEntryInfo) { static CryFixedStringT<MAX_AUDIO_FILE_PATH_LENGTH> sPath; sPath = m_sGameFolder.c_str(); sPath += ms_sSDLSoundLibraryPath; return sPath.c_str(); }
SMMMigrateCompletedEvent::SMMMigrateCompletedEvent( CryFixedStringT<DISPLAY_NAME_LENGTH>& newServer, CrySessionID& sessionId ) { cry_strncpy( m_newServer, newServer.c_str(), sizeof(m_newServer) ); sessionId->AsCStr( m_newSessionID, sizeof(m_newSessionID) ); size = sizeof( SMMMigrateCompletedEvent ); type = eMMTelE_MigrateCompleted; }
void CNetLerper::AddNewPoint(const Vec3& inPos, const Vec3& inVel, const Vec3& entityPos, EntityId standingOn) { CRY_ASSERT(m_settings); m_desired.pos = inPos; m_desired.worldPos = inPos; m_standingOn = standingOn; if (IEntity* pGroundEntity = gEnv->pEntitySystem->GetEntity(standingOn)) { m_desired.worldPos = pGroundEntity->GetWorldTM() * inPos; } // Run the desired velocity at slightly below the real velocity // helps to smooth the lerping since there is large granularity in // the network quantisation of the velocity m_desired.vel = inVel * 0.9f; #if SNAP_ERROR_LOGGING if (m_snapErrorInProgress) { if ((m_pPlayer != NULL) && (!m_pPlayer->IsDead())) { CryFixedStringT<128> buffer; buffer.Format("[netlerper] prediction error ended for [%s] after %fs", m_pPlayer->GetEntity()->GetName(), m_clock); #if ENABLE_STATOSCOPE if(gEnv->pStatoscope) { gEnv->pStatoscope->AddUserMarker("NetLerper", buffer.c_str()); } #endif // ENABLE_STATOSCOPE CryLog(buffer.c_str()); m_snapErrorInProgress = false; } } #endif // SNAP_ERROR_LOGGING // Zero clock and re calibrate the lerp error m_clock = 0.f; m_lerpedError = entityPos - m_desired.worldPos; m_lerpedPos = m_desired.worldPos; m_enabled = true; }
void COptionsManager::SetAntiAliasingMode(const char* params) { if(params) { if(g_pGame->GetMenu()) { CFlashMenuObject::FSAAMode mode = g_pGame->GetMenu()->GetFSAAMode(params); if(mode.samples == 0) { gEnv->pConsole->ExecuteString("r_fsaa 0"); gEnv->pConsole->ExecuteString("r_fsaa_samples 0"); gEnv->pConsole->ExecuteString("r_fsaa_quality 0"); } else { gEnv->pConsole->ExecuteString("r_fsaa 1"); CryFixedStringT<32> command = "r_fsaa_samples "; char buffer[16]; itoa(mode.samples, buffer, 10); command.append(buffer); gEnv->pConsole->ExecuteString(command.c_str()); command = "r_fsaa_quality "; itoa(mode.quality, buffer, 10); command.append(buffer); gEnv->pConsole->ExecuteString(command.c_str()); // FSAA requires HDR mode on, to get consistent menu settings we switch sys_spec_shading to 3 or 4 // search for #LABEL_FSAA_HDR { bool bHDREnabled = gEnv->pRenderer->EF_Query(EFQ_HDRModeEnabled)!=0; if(!bHDREnabled) // no HDR so we either have sys_spec_Shading in 1 or 2 or user { // (it cannot be the machine is not capable of HDR as we have a list of FSAA modes) ICVar *pSpecShading = gEnv->pConsole->GetCVar("sys_spec_Shading"); assert(pSpecShading); if(pSpecShading) pSpecShading->Set(3); // starting with mode 3 we have HDR on } } } } } }
virtual void ProcessEvent(EFlowEvent flowEvent, SActivationInfo *pActivationInfo) { if(flowEvent == eFE_Activate && IsPortActive(pActivationInfo, EIP_SetLimit)) { const float fVal = GetPortFloat(pActivationInfo, EIP_Limit); CryFixedStringT<128> buf; buf.FormatFast("%g", fVal); g_pGameCVars->pAltitudeLimitCVar->ForceSet(buf.c_str()); } }
void COptionsManager::CCVarSink::OnElementFound(ICVar *pCVar) { if (pCVar == 0) return; CryFixedStringT<128> szLine = pCVar->GetName(); CryFixedStringT<128> szValue = pCVar->GetString(); // only save if we have an option to it std::map<string, SOptionEntry>::const_iterator iter = m_pOptionsManager->m_profileOptions.find(CONST_TEMP_STRING(pCVar->GetName())); if (iter == m_pOptionsManager->m_profileOptions.end()) return; const SOptionEntry& entry = iter->second; if (entry.bWriteToConfig == false) return; size_t pos; // replace \ with \\ pos = 1; for(;;) { pos = szValue.find_first_of("\\", pos); if (pos == CryFixedStringT<128>::npos) { break; } szValue.replace(pos, 1, "\\\\", 2); pos+=2; } // replace " with \" pos = 1; for(;;) { pos = szValue.find_first_of("\"", pos); if (pos == CryFixedStringT<128>::npos) { break; } szValue.replace(pos, 1, "\\\"", 2); pos+=2; } if(pCVar->GetType()==CVAR_STRING) szLine += " = \"" + szValue + "\"\r\n"; else szLine += " = " + szValue + "\r\n"; fputs(szLine.c_str(), m_pFile); }
void CCheckpointSystem::GetCurrentLevelCheckpoints(std::vector<string> &saveNames) { //get current level const char *levelName = CCryAction::GetCryAction()->GetLevelName(); CryFixedStringT<32> curlevelName = levelName; if(levelName) CCheckpointSystem::GetInstance()->RepairLevelName(curlevelName); //parse savegames fitting current level ParseSavedFiles(saveNames, curlevelName.c_str()); }
bool CDLCManager::VerifyCRCs(const XmlNodeRef &crcNode, const char* sDLCRootFolder) { bool success = true; CryFixedStringT<ICryPak::g_nMaxPath> path; int numFiles = crcNode->getChildCount(); XmlString fileName; uint32 storedCrc; for (int i=0; i<numFiles; ++i) { XmlNodeRef fileNode = crcNode->getChild(i); if (fileNode->getAttr("name", fileName) && fileNode->getAttr("crc", storedCrc)) { bool useCryFile = false; #if defined(WIN32) || defined(WIN64) path.Format("%s/%s", sDLCRootFolder, fileName.c_str()); useCryFile = true; #else CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "No Platform defined in DLCManager" ); #endif CryLog( "CRC: Checking CRC of %s", path.c_str() ); success = gEnv->pCryPak->OpenPack( path.c_str() ); if( !success ) { CryLog( "CRC: Failed to open pack" ); } uint32 computedCrc = gEnv->pCryPak->ComputeCachedPakCDR_CRC( path.c_str(), useCryFile ); if (computedCrc != storedCrc) { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CRC on file %s (%u) does not match stored value (%u)", path.c_str(), computedCrc, storedCrc); success = false; } gEnv->pCryPak->ClosePack( path.c_str() ); } } return success; }
void CNetLerper::LogSnapError() { #if SNAP_ERROR_LOGGING if (!m_snapErrorInProgress) { if ((m_pPlayer != NULL) && (!m_pPlayer->IsDead())) { CryFixedStringT<128> buffer; buffer.Format("[netlerper] prediction error started for [%s]", m_pPlayer->GetEntity()->GetName()); #if ENABLE_STATOSCOPE if(gEnv->pStatoscope) { gEnv->pStatoscope->AddUserMarker("NetLerper", buffer.c_str()); } #endif // ENABLE_STATOSCOPE CryLog(buffer.c_str()); m_snapErrorInProgress = true; } } #endif // SNAP_ERROR_LOGGING }
static bool ModInfo_LoadFromXML(ModInfo* pMod, const XmlNodeRef& pRoot) { ModInfo_FetchAttribute(&pMod->displayName, pRoot, "Name", "name"); ModInfo_FetchAttribute(&pMod->author, pRoot, "Author", "name"); CryFixedStringT<32> type; if (ModInfo_FetchAttribute(&type, pRoot, "Type", "name")) pMod->modType = ModInfoTypeFromString(type.c_str()); ModInfo_FetchAttribute(&pMod->website, pRoot, "URL", "address"); ModInfo_FetchAttribute(&pMod->versionMajor, pRoot, "Version", "major"); ModInfo_FetchAttribute(&pMod->versionMinor, pRoot, "Version", "minor"); ModInfo_FetchContent(&pMod->description, pRoot, "Description"); return true; }
SMMPlayerLeftMMEvent::SMMPlayerLeftMMEvent( SCryUserInfoResult* pUser, CrySessionID& id, int32 nCurrentPlayers, bool isLocal ) { CryFixedStringT<40> guid = pUser->m_userID.get()->GetGUIDAsString(); CryLog( "MMTel: User guid %s", guid.c_str() ); if( pUser->m_userID.get() ) { cry_sprintf( m_guid, sizeof(m_guid), guid.c_str() ); } else { m_guid[0]=0; } memcpy( m_userName, pUser->m_userName, sizeof(m_userName) ); id->AsCStr( m_sessionID, sizeof(m_sessionID) ); m_nCurrentPlayers = nCurrentPlayers; m_local = isLocal; size = sizeof( SMMPlayerLeftMMEvent ); type = eMMTelE_PlayerLeftMM; }
int CScriptBind_Boids::GetUsableMessage(IFunctionHandler *pH, SmartScriptTable flockEntity) { CFlock* flock = GetFlock(flockEntity); IActor* pActor = g_pGame->GetIGameFramework()->GetClientActor(); if (pActor) { CPlayer* pPlayer = static_cast<CPlayer*>(pActor); CryFixedStringT<64> finalString; CryFixedStringT<64> tempString; if (pPlayer && !pPlayer->IsInPickAndThrowMode() && flock != NULL) { SBoidContext bc; flock->GetBoidSettings(bc); tempString.Format("@ui_boid_pickup %s", bc.pickableMessage); finalString = CHUDUtils::LocalizeString(tempString.c_str()); } return pH->EndFunction(finalString.c_str()); } return pH->EndFunction(); }
void CFlowGraphModuleManager::ScanFolder(const string& folderName, bool bGlobal) { _finddata_t fd; intptr_t handle = 0; ICryPak *pPak = gEnv->pCryPak; CryFixedStringT<512> searchString = folderName.c_str(); searchString.append("*.*"); handle = pPak->FindFirst(searchString.c_str(), &fd); CryFixedStringT<512> moduleName(""); string newFolder(""); if (handle > -1) { do { if (!strcmp(fd.name, ".") || !strcmp(fd.name, "..") || (fd.attrib & _A_HIDDEN)) continue; if (fd.attrib & _A_SUBDIR) { newFolder = folderName; newFolder = newFolder + fd.name; newFolder = newFolder + "\\"; ScanFolder(newFolder, bGlobal); } else { moduleName = fd.name; if(!strcmpi(PathUtil::GetExt(moduleName.c_str()), "xml")) { PathUtil::RemoveExtension(moduleName); PathUtil::MakeGamePath(folderName); // initial load: creates module, registers nodes CFlowGraphModule* pModule = PreLoadModuleFile(moduleName.c_str(), PathUtil::GetPath(folderName)+fd.name, bGlobal); // important: the module should be added using its internal name rather than the filename m_ModulesPathInfo.insert(TModulesPathInfo::value_type(pModule->GetName(), PathUtil::GetPath(folderName)+fd.name)); } } } while (pPak->FindNext(handle, &fd) >= 0); pPak->FindClose(handle); } }
//------------------------------------------------------------------------ bool CPlaylistActivityTracker::RequestCurrentActivity( PlayListActivityCallback callback ) { bool success = false; // Don't start another request if we're already waiting on one if( ! AnyActiveRequestsOfType( eRTT_RequestActivity ) ) { CryFixedStringT<MAX_CONTENT> httpParams; httpParams.Format( "?platform=1"); success = UploadData( "playlist/all_playlist_activity/", httpParams.c_str(), 4096, eRTT_RequestActivity ); m_currentActivityCallback = callback; } return success; }
//------------------------------------------------------------------------ bool CPlaylistActivityTracker::CreatedGame( ILevelRotation::TExtInfoId playlistId, uint32 variantId ) { bool success = false; //ensure service is initialised if(! AnyActiveRequestsOfType( eRTT_AnnounceCreateGame ) ) { //construct the http request CryFixedStringT<MAX_CONTENT> httpParams; httpParams.Format( "?platform=1&playlist=%d&variant=%d", playlistId, variantId ); success = UploadData( "playlist/game_created/", httpParams.c_str(), 1024, eRTT_AnnounceCreateGame ); } return success; }
////////////////////////////////////////////////////////////////////////// // Session Quality Events SMMPlayerJoinedEvent::SMMPlayerJoinedEvent( CryFixedStringT<CRYLOBBY_USER_NAME_LENGTH>& name, CryUserID& uid, SCryMatchMakingConnectionUID& conUID ) { if( uid.get() ) { cry_sprintf( m_guid, sizeof(m_guid), uid.get()->GetGUIDAsString().c_str() ); } else { m_guid[0]=0; } m_conUID = conUID; cry_sprintf( m_name, sizeof(m_name), name.c_str() ); size = sizeof( SMMPlayerJoinedEvent ); type = eMMTelE_PlayerJoined; }
//------------------------------------------------------------------------ void CVehicleSeatActionRotateTurret::Serialize(TSerialize ser, EEntityAspects aspects) { // MR: for network, only turret parts are serialized // for savegame, all parts are serialized (by CVehicle) if (ser.GetSerializationTarget() == eST_Network) { for (int i = 0; i < eVTRT_NumRotationTypes; ++i) { if (m_rotations[i].m_pPart) { m_rotations[i].m_pPart->Serialize(ser, aspects); } } } else { // save rotation details CryFixedStringT<16> tag; for (int i = 0; i < eVTRT_NumRotationTypes; ++i) { if (m_rotations[i].m_pPart) { Quat q; Matrix34 currentTM = m_rotations[i].m_pPart->GetLocalBaseTM(); if (ser.IsWriting()) q = Quat(currentTM); tag = (i == eVTRT_Pitch) ? "rotation_pitch" : "rotation_yaw"; ser.Value(tag.c_str(), q, 'ori1'); if (ser.IsReading()) { Matrix34 newTM(q); newTM.SetTranslation(currentTM.GetTranslation()); m_rotations[i].m_pPart->SetLocalBaseTM(newTM); m_rotations[i].m_orientation.Set(q); } } } } }
void CProfileOptions::CCVarSink::OnElementFound(ICVar *pCVar) { if (pCVar == 0) return; const char* name = pCVar->GetName(); const char* val = pCVar->GetString(); COption* pOption = m_pOptions->GetOptionByCVar(name); if(!pOption) return; if(!pOption->IsWriteToConfig()) return; const char* optionName = pOption->GetName().c_str(); const char* writeValue = pOption->Get().c_str(); const std::vector<SPendingOption>& pendingOptions = m_pOptions->GetPendingOptions(); std::vector<SPendingOption>::const_iterator it = pendingOptions.begin(); std::vector<SPendingOption>::const_iterator end = pendingOptions.end(); for(; it!=end; ++it) { const SPendingOption& option = (*it); if(!option.writeToConfig) continue; if(option.command.compareNoCase(optionName)) continue; writeValue = option.param.c_str(); break; } CryFixedStringT<128> format; pOption->GetWriteToConfigString(format, pCVar, writeValue); fputs(format.c_str(), m_pFile); }