//------------------------------------------------------------------------ void CGunTurret::UpdateGoal(IEntity *pTarget, float deltaTime) { Vec3 shootPos = PredictTargetPos(pTarget,false); if(m_turretparams.sweep_time != 0.f && !m_fireparams.hints.empty()) shootPos = GetSweepPos(pTarget, shootPos); if(m_fireparams.deviation_amount != 0.f) UpdateDeviation(deltaTime, shootPos); float goalYaw(0.f), goalPitch(0.f); if(!GetTargetAngles(shootPos, goalYaw, goalPitch)) return; if(!IsTargetAimable(goalYaw,goalPitch)) { if(DebugTurret()) CryLog("UpdateGoal: %s IsTargetAimable failed (yaw: %.2f, pitch: %.2f)", pTarget->GetName(), goalYaw, goalPitch); return; } // if (cry_fabsf(m_goalYaw-goalYaw)<0.0001f && cry_fabsf(m_goalPitch-m_goalPitch)<0.0001f ) // return; m_goalPitch = goalPitch; m_goalYaw = goalYaw; GetGameObject()->ChangedNetworkState(ASPECT_GOALORIENTATION); }
//------------------------------------------------------------------------ float CGameRulesCommonDamageHandling::GetVehicleForeignCollisionMultiplier( const IVehicle& vehicle, const SCollisionEntityInfo& colliderInfo, const CGameRules::SCollisionHitInfo& colHitInfo ) const { float result = 1.0f; //Vehicle to vehicle collision if (colliderInfo.pEntityVehicle) { const float vehicleMass = vehicle.GetMass(); const float vehicleColliderMass = colliderInfo.pEntityVehicle->GetMass(); const float targetSpeedSqr = colHitInfo.target_velocity.len2(); if ((vehicleMass > vehicleColliderMass * 1.5f) && (targetSpeedSqr > 0.01f)) { //Reduce damage for collisions with large mass ratios, to avoid instant-killing const float ratio = 1.0f + (0.35f * min(10.0f, vehicleMass * __fres(vehicleColliderMass))) * min(1.0f, targetSpeedSqr * 0.31623f); result = __fres(ratio); if (DebugCollisions()) { CryLog("Vehicle/Vehicle (%s <- %s), collision mult: %.2f", vehicle.GetEntity()->GetName(), colliderInfo.pEntity->GetName(), result); } } } return result; }
void CMelee::GenerateAndQueueMeleeAction() const { const SMeleeTags& tags = m_pMeleeParams->meleetags; const CWeaponMelee::EMeleeStatus meleeStatus = static_cast<CWeaponMelee*> (m_pWeapon)->GetMeleeAttackAction(); const char* pActionName = NULL; switch( meleeStatus ) { case CWeaponMelee::EMeleeStatus_Left: GenerateAndQueueMeleeActionForStatus( tags.tag_params_combo_left ); pActionName = "MeleeCombo"; break; case CWeaponMelee::EMeleeStatus_Right: GenerateAndQueueMeleeActionForStatus( tags.tag_params_combo_right ); pActionName = "MeleeCombo"; break; case CWeaponMelee::EMeleeStatus_KillingBlow: GenerateAndQueueMeleeActionForStatus( tags.tag_params_combo_killingblow ); pActionName = "MeleeKillingBlow"; break; default: CryLog( "[Melee] Attempted to run a melee action when the status was unknown" ); break; } }
//------------------------------------------------------------------------ void CGameRulesHoldObjectiveBase::Init( XmlNodeRef xml ) { const int numChildren = xml->getChildCount(); for (int childIdx = 0; childIdx < numChildren; ++ childIdx) { XmlNodeRef xmlChild = xml->getChild(childIdx); if (!stricmp(xmlChild->getTag(), "SpawnParams")) { const char *pType = 0; if (xmlChild->getAttr("type", &pType)) { if (!stricmp(pType, "avoid")) { m_spawnPOIType = eSPT_Avoid; } else { CryLog("CGameRulesHoldObjectiveBase::Init: ERROR: Unknown spawn point of interest type ('%s')", pType); } xmlChild->getAttr("distance", m_spawnPOIDistance); } } else if (!stricmp(xmlChild->getTag(), "EffectData")) { InitEffectData(xmlChild); } } for (int i = 0; i < HOLD_OBJECTIVE_MAX_ENTITIES; ++ i) { m_entities[i].Reset(); } }
TBitfield AutoEnum_GetBitfieldFromString(const char * inString, const char ** inArray, int arraySize) { unsigned int reply = 0; if (inString && inString[0] != '\0') // Avoid a load of work if the string's NULL or empty { const char * startFrom = inString; assert (arraySize > 0); char skipThisString[32]; size_t skipChars = cry_copyStringUntilFindChar(skipThisString, inArray[0], sizeof(skipThisString), '_'); size_t foundAtIndex = 0; #if DO_PARSE_BITFIELD_STRING_LOGS CryLog("AutoEnum_GetBitfieldFromString: Parsing '%s' (skipping first %d chars '%s%s' of each string in array)", inString, skipChars, skipThisString, skipChars ? "_" : ""); #endif do { char gotToken[32]; foundAtIndex = cry_copyStringUntilFindChar(gotToken, startFrom, sizeof(gotToken), '|'); startFrom += foundAtIndex; bool done = false; for (int i = 0; i < arraySize; ++ i) { if (0 == stricmp(inArray[i] + skipChars, gotToken)) { CRY_ASSERT_MESSAGE((reply & BIT(i)) == 0, string().Format("Bit '%s' already turned on! Does it feature more than once in string '%s'?", gotToken, inString)); #if DO_PARSE_BITFIELD_STRING_LOGS CryLog("AutoEnum_GetBitfieldFromString: Token = '%s' = BIT(%d) = %d, remaining string = '%s'", gotToken, i, BIT(i), foundAtIndex ? startFrom : ""); #endif reply |= BIT(i); done = true; break; } } CRY_ASSERT_MESSAGE(done, string().Format("No flag called '%s' in list", gotToken)); } while (foundAtIndex); } return reply; }
//------------------------------------------------------------------------- bool CGameBrowser::DoFavouriteIdSearch() { CryLog("[UI] DoFavouriteIdSearch"); bool bResult = false; return bResult; }
//------------------------------------------------------------------------ IMPLEMENT_RMI(CGameRules, ClMidMigrationJoin) { CryLog("CGameRules::ClMidMigrationJoin() state=%i, timeSinceChange=%f", params.m_state, params.m_timeSinceStateChanged); CGame::EHostMigrationState newState = CGame::EHostMigrationState(params.m_state); float timeOfChange = gEnv->pTimer->GetAsyncCurTime() - params.m_timeSinceStateChanged; g_pGame->SetHostMigrationStateAndTime(newState, timeOfChange); return true; }
//------------------------------------------------------------------------ CGameRulesCommonDamageHandling::CGameRulesCommonDamageHandling() : m_pGameRules(NULL) { CryLog("GameRulesCommonDamageHandling::GameRulesCommonDamageHandling()"); IEntityClassRegistry * pClassReg = gEnv->pEntitySystem->GetClassRegistry(); m_pEnvironmentalWeaponClass = pClassReg->FindClass("EnvironmentalWeapon"); }
//------------------------------------------------------------------------ void CMatchMakingHandler::Search( int freeSlots, int maxResults, SCrySessionSearchData* searchParameters, int numSearchParameters ) { //might still want equivalents of these //m_findGameTimeout = GetFindGameTimeout(); //m_findGameResults.clear(); SCrySessionSearchParam param; param.m_type = FIND_GAME_SESSION_QUERY; param.m_data = searchParameters; param.m_numFreeSlots = freeSlots; CRY_ASSERT(param.m_numFreeSlots > 0); param.m_maxNumReturn = maxResults; param.m_ranked = false; int curData = 0; CRY_ASSERT_MESSAGE( numSearchParameters < FIND_GAMES_SEARCH_NUM_DATA, "Session search data buffer overrun" ); searchParameters[ numSearchParameters ].m_operator = eCSSO_Equal; searchParameters[ numSearchParameters ].m_data.m_id = LID_MATCHDATA_VERSION; searchParameters[ numSearchParameters ].m_data.m_type = eCLUDT_Int32; searchParameters[ numSearchParameters ].m_data.m_int32 = GameLobbyData::GetVersion(); numSearchParameters++; param.m_numData = numSearchParameters; ++s_currentMMSearchID; #if defined(TRACK_MATCHMAKING) if( CMatchmakingTelemetry* pMMTel = g_pGame->GetMatchMakingTelemetry() ) { pMMTel->AddEvent( SMMStartSearchEvent( param, s_currentMMSearchID ) ); } #endif ECryLobbyError result = g_pGame->GetGameBrowser()->StartSearchingForServers(¶m, CMatchMakingHandler::SearchCallback, this, false); if (result == eCLE_Success) { CryLog("MatchMakingHandler::Search() search successfully started, ");//setting s_bShouldBeSearching to FALSE to prevent another one starting"); } else { CryLog("MatchMakingHandler::Search() search failed to start (error=%i)", result);// setting s_bShouldBeSearching to TRUE so we start another one when the timeout occurs", result); } }
void CMatchMakingHandler::MMLog( const char* message, bool isError ) { if( isError ) { CryLog( "MMHandlerError: %s", message ); } else { CryLog( "MMHandlerLog: %s", message ); } if( CMatchmakingTelemetry* pMMTel = g_pGame->GetMatchMakingTelemetry() ) { pMMTel->AddEvent( SMMGenericLogEvent( message, isError ) ); } }
/* static */ bool CGameBrowser::CreatePresenceString(CryFixedStringT<MAX_PRESENCE_STRING_SIZE> &out, SCryLobbyUserData *pData, uint32 numData) { bool result = true; if(numData > 0) { CRY_ASSERT_MESSAGE(pData[CRichPresence::eRPT_String].m_id == RICHPRESENCE_ID, ""); // pData[0] indicates the type of rich presence we setting, i.e. frontend, lobby, in-game // additional pData's are parameters that can be passed into the rich presence string, only used for gameplay at the moment switch(pData[CRichPresence::eRPT_String].m_int32) { case RICHPRESENCE_FRONTEND: LocalisePresenceString(out, "@mp_rp_frontend"); break; case RICHPRESENCE_LOBBY: LocalisePresenceString(out, "@mp_rp_lobby"); break; case RICHPRESENCE_GAMEPLAY: if(numData == 3) { const int gameModeId = pData[CRichPresence::eRPT_Param1].m_int32; const int mapId = pData[CRichPresence::eRPT_Param2].m_int32; LocaliseInGamePresenceString( out, "@mp_rp_gameplay", gameModeId, mapId ); } #if !defined(_RELEASE) else { CRY_ASSERT_MESSAGE(numData == 3, "Invalid data passed for gameplay rich presence state"); result = false; } #endif break; case RICHPRESENCE_SINGLEPLAYER: LocalisePresenceString(out, "@mp_rp_singleplayer"); break; case RICHPRESENCE_IDLE: LocalisePresenceString(out, "@mp_rp_idle"); break; default: CRY_ASSERT_MESSAGE(false, "[RichPresence] unknown rich presence type given"); result = false; break; } } else { CryLog("[RichPresence] Failed to set rich presence because numData was 0 or there was no hud"); result = false; } return result; }
//------------------------------------------------------------------------ void CParachute::PhysicalizeCanvas(bool enable) { IEntity* pCanvas = m_pEntitySystem->GetEntity(m_canvasId); if (!pCanvas) return; if (enable) { SEntityPhysicalizeParams params; params.type = PE_RIGID; params.mass = 0; pCanvas->Physicalize(params); IPhysicalEntity* pPhysics = pCanvas->GetPhysics(); if (!pPhysics) return; // add parachute physics geometry m_paraPhysIds.clear(); m_paraPhysIds.resize(8); for(int iCel=0; iCel<7; iCel++) { SWing *pCel = &m_aCels[iCel]; m_paraPhysIds.push_back( AddCel(pPhysics, iCel+1, pCel) ); pCel->fSurface = pCel->vSize.x * pCel->vSize.y; pCel->pLiftPointsMap = &m_LiftPointsMap; pCel->pDragPointsMap = &m_DragPointsMap; } Vec3 minExt(0.0f,0.0f,0.95f), maxExt(0.5f,0.3f,1.9f); m_paraPhysIds.push_back( AddBox(&minExt, &maxExt, 70.0f) ); pe_params_part pp; pp.partid = m_paraPhysIds.back(); pp.flagsAND = ~(geom_collides); pPhysics->SetParams(&pp); pe_status_dynamics stats; pPhysics->GetStatus(&stats); CryLog("Parachute mass: %f", stats.mass); } else { IPhysicalEntity* pPhysics = pCanvas->GetPhysics(); if (pPhysics) { // remove parachute geometry for (std::vector<int>::iterator it = m_paraPhysIds.begin(); it != m_paraPhysIds.end(); ++it) { pPhysics->RemoveGeometry(*it); } } m_paraPhysIds.clear(); } }
//------------------------------------------------------------------------ void CGameRules::StoreMigratingPlayer(IActor* pActor) { if (pActor == NULL) { GameWarning("Invalid data for migrating player"); return; } IEntity* pEntity = pActor->GetEntity(); EntityId id = pEntity->GetId(); bool registered = false; uint16 channelId = pActor->GetChannelId(); CRY_ASSERT(channelId); bool bShouldAdd = true; CGameLobby *pGameLobby = g_pGame->GetGameLobby(); CRY_ASSERT(pGameLobby); if (pGameLobby) { SCryMatchMakingConnectionUID conId = pGameLobby->GetConnectionUIDFromChannelID((int) channelId); if (pGameLobby->GetSessionNames().Find(conId) == SSessionNames::k_unableToFind) { CryLog("CGameRules::StoreMigratingPlayer() player %s (channelId=%u) has already left the game, not storing", pEntity->GetName(), channelId); bShouldAdd = false; } } if (bShouldAdd && (!m_hostMigrationCachedEntities.empty())) { if (!stl::find(m_hostMigrationCachedEntities, pActor->GetEntityId())) { bShouldAdd = false; } } if (bShouldAdd) { for (uint32 index = 0; index < m_migratingPlayerMaxCount; ++index) { if (!m_pMigratingPlayerInfo[index].InUse()) { m_pMigratingPlayerInfo[index].SetData(pEntity->GetName(), id, GetTeam(id), pEntity->GetWorldPos(), pEntity->GetWorldAngles(), pActor->GetHealth()); m_pMigratingPlayerInfo[index].SetChannelID(channelId); registered = true; break; } } } pEntity->Hide(true); // Hide the player, they will be unhidden when they rejoin if (!registered && bShouldAdd) { GameWarning("Too many migrating players!"); } }
void CReadSendPacket::SendMsg(SOCKET Socket, SMessage message) { //CryLog("[CryMasterServer] Send message packet..."); SPacket SPacket; Packet* p = new Packet(); p->create(); /****************************Обязательный блок************************************/ p->writeInt(PACKET_MESSAGE); // Тип пакета p->writeString(gClientEnv->clientVersion); // Версия пакета /*******************************Тело пакета****************************************/ p->writeString(message.message); p->writeInt(message.area); p->writeString(EndBlock); // Завершающий блок p->padPacketTo8ByteLen(); p->encodeBlowfish(gClientEnv->bBlowFish); p->appendChecksum(false); p->appendMore8Bytes(); int size = p->getPacketSize(); char* packet = (char*)p->getBytesPtr(); SPacket.addr = Socket; SPacket.data = packet; SPacket.size = size; gClientEnv->pPacketQueue->InsertPacket(SPacket); if(gClientEnv->bDebugMode) { CryLog("[CryMasterServer] Message packet size = %d",size); CryLog("[CryMasterServer] Message packet data = %s",message.message); CryLog("[CryMasterServer] Message packet type = %d",message.area); PacketDebugger::Debug(packet, size, "SendPacketsDebugg.txt"); } }
//------------------------------------------------------------------------- void CGameLobbyManager::MoveUsers(CGameLobby *pFromLobby) { CryLog("[GameLobbyManager] MoveUsers pFromLobby %p pToLobby %p", pFromLobby, m_nextLobby); if(m_nextLobby) { m_nextLobby->MoveUsers(pFromLobby); } }
//------------------------------------------------------------------------ bool CGameRules::OnFinalise(SHostMigrationInfo& hostMigrationInfo, uint32& state) { if (!g_pGame->GetIGameFramework()->ShouldMigrateNub(hostMigrationInfo.m_session)) { return true; } CryLogAlways("[Host Migration]: CGameRules::OnFinalise() started"); //if (m_hostMigrationClientHasRejoined) { CCCPOINT(HostMigration_OnFinalise); if (!hostMigrationInfo.IsNewHost()) { FlushPhysicsQueues(); int numEntities = m_hostMigrationCachedEntities.size(); CryLog(" removing %i entities", numEntities); for (int i = 0; i < numEntities; ++ i) { EntityId entId = m_hostMigrationCachedEntities[i]; gEnv->pEntitySystem->RemoveEntity(entId, true); TEntityTeamIdMap::iterator entityTeamsIt = m_entityteams.begin(); for (; entityTeamsIt != m_entityteams.end(); ++ entityTeamsIt) { EntityId entityId = entityTeamsIt->first; if (entityId == entId) { int teamId = entityTeamsIt->second; if (teamId) { // Remove this entity from the team lists TPlayers &playersVec = m_playerteams[teamId]; stl::find_and_erase(playersVec, entId); m_entityteams.erase(entityTeamsIt); } break; } } } } m_hostMigrationCachedEntities.clear(); HostMigrationResumeAddingPlayers(); g_pGame->PlayerIdSet(g_pGame->GetIGameFramework()->GetClientActorId()); CryLogAlways("[Host Migration]: CGameRules::OnFinalise() finished - success"); return true; } CryLogAlways("[Host Migration]: CGameRules::OnFinalise() finished - failure"); return false; }
static void LogLuaCacheResource(const char* whoIsRequesting, const char* type, const char* resourceName, const int flags) { #if LOG_CACHE_RESOURCES_FROM_LUA if (resourceName && resourceName[0]) { CryLog("[GAME CACHE LUA] by '%s' : %s - %s Flags(%d)", whoIsRequesting, type, resourceName, flags); } #endif }
void CPersistantDebug::AddEntityTag(const SEntityTagParams& params, const char *tagContext) { // Create tag SEntityTag tag; tag.params = params; tag.params.column = max(1, tag.params.column); tag.params.visibleTime = max(0.f, tag.params.visibleTime); tag.params.fadeTime = max(0.f, tag.params.fadeTime); if (tagContext != NULL && *tagContext != '\0') tag.params.tagContext = tagContext; tag.totalTime = tag.params.visibleTime + tag.params.fadeTime; tag.totalFadeTime = tag.params.fadeTime; tag.vScreenPos.zero(); SObj *obj = FindObj(params.entity); if (!obj) { // Create new object to push back SObj sobj; sobj.obj = eOT_EntityTag; sobj.entityId = params.entity; sobj.entityHeight = 0.f; sobj.timeRemaining = tag.totalTime; sobj.totalTime = tag.totalTime; sobj.columns.resize(params.column); AddToTagList(sobj.tags, tag); m_objects[entityTagsContext].push_back(sobj); } else { obj->timeRemaining = max(obj->timeRemaining, tag.totalTime); obj->totalTime = obj->timeRemaining; int size = max(int(obj->columns.size()), params.column); if (obj->columns.size() < size) obj->columns.resize(size); AddToTagList(obj->tags, tag); } if (m_pETLog->GetIVal() > 0) { IEntity *ent = gEnv->pEntitySystem->GetEntity(params.entity); if (ent) { CryLog("[Entity Tag] %s added tag: %s", ent->GetName(), params.text.c_str()); if (m_pETLog->GetIVal() > 1) { char text[256]; _snprintf(text, sizeof(text), "[Entity Tag] %s", params.text.c_str()); gEnv->pAISystem->Record(ent->GetAI(), IAIRecordable::E_NONE, text); } } } }
//------------------------------------------------------------------------ float CMatchMakingHandler::LegacyC2MatchMakingScore( SCrySessionSearchResult* session, CGameLobby *lobby, bool includeRand ) { //Creates sub metrics (between 0-1 (1 being best)) CGameLobbyCVars *pGameLobbyCVars = CGameLobbyCVars::Get(); const CGameLobby::EActiveStatus activeStatus = (CGameLobby::EActiveStatus) GameLobbyData::GetSearchResultsData( session, LID_MATCHDATA_ACTIVE ); const float pingScale = pGameLobbyCVars ? pGameLobbyCVars->gl_findGamePingScale : 1.f; const float idealPlayerCount = pGameLobbyCVars ? pGameLobbyCVars->gl_findGameIdealPlayerCount : 1.f; float pingSubMetric = 1.0f - clamp_tpl((session->m_ping / pingScale), 0.0f, 1.0f); //300ms or above gives you a 0 rating float playerSubMetric = clamp_tpl((float)session->m_numFilledSlots / idealPlayerCount, 0.0f, 1.0f); //more players the better float lobbySubMetric = (activeStatus != CGameLobby::eAS_Lobby) ? 0.0f : 1.f; // Prefer games that haven't started yet float skillSubMetric = 0.f; const int skillRank = lobby->CalculateAverageSkill(); const int sessionSkillRank = GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_SKILL); if (skillRank) { float diff = (float) abs(skillRank - sessionSkillRank); float fracDiff = diff / (float) skillRank; skillSubMetric = 1.f - MIN(fracDiff, 1.f); skillSubMetric = (skillSubMetric * skillSubMetric); } int32 languageId = lobby->GetCurrentLanguageId(); float languageSubMetric = 0.f; if (languageId == GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_LANGUAGE)) { languageSubMetric = 1.f; } float randomSubMetric = ((float) (g_pGame->GetRandomNumber() & 0xffff)) / ((float) 0xffff); if(pGameLobbyCVars) { pingSubMetric *= pGameLobbyCVars->gl_findGamePingMultiplier; playerSubMetric *= pGameLobbyCVars->gl_findGamePlayerMultiplier; lobbySubMetric *= pGameLobbyCVars->gl_findGameLobbyMultiplier; skillSubMetric *= pGameLobbyCVars->gl_findGameSkillMultiplier; languageSubMetric *= pGameLobbyCVars->gl_findGameLanguageMultiplier; randomSubMetric *= pGameLobbyCVars->gl_findGameRandomMultiplier; } float score = pingSubMetric + playerSubMetric + lobbySubMetric + skillSubMetric + languageSubMetric; if( includeRand ) { score += randomSubMetric; } CryLog("MMLua: Final Score %.2f", score ); return score; }
//------------------------------------------------------------------------ void CGunTurret::InternalStopFire(bool sec) { if(g_pGameCVars->i_debug_turrets) CryLog("%s StopFire(%i)", GetEntity()->GetName(), sec ? 2 : 1); if(!sec) CWeapon::StopFire(); else if(m_fm2) m_fm2->StopFire(); }
void CDataPatchDownloader::DataFailedToDownload( CDownloadableResourcePtr inResource) { // nothing to do, leave CRC at default value CryLog("Failed to download data patch"); if (m_pListener) { m_pListener->DataPatchNotAvailable(); } }
//--------------------------------------- void CMiscAnnouncer::Reset() { CryLog("CMiscAnnouncer::Reset()"); for (TWeaponFiredMap::iterator it=m_weaponFiredMap.begin(); it != m_weaponFiredMap.end(); ++it) { SOnWeaponFired &onWeaponFired = it->second; onWeaponFired.Reset(); } }
//AddSpawnLocation and RemoveSpawnLocation should not be called at run time as they will corrupt the networking index data void CGameRulesSpawningBase::AddSpawnLocation(EntityId location, bool isInitialSpawn, bool doVisTest, const char *pGroupName) { if (isInitialSpawn) { TSpawnLocations *pGroup = GetSpawnLocationsFromGroup(m_initialSpawnLocations, pGroupName); stl::push_back_unique(*pGroup, location); if (g_pGameCVars->g_debugSpawnPointsRegistration != 0) CryLog("[SPAWN POINT]Adding initial spawn point to game rules, Id = '%d' (group='%s'). Number of initial Spawn points in group = '%" PRISIZE_T "'", location, pGroupName, pGroup->size()); } else { stl::push_back_unique(m_spawnLocations, location); if (g_pGameCVars->g_debugSpawnPointsRegistration != 0) CryLog("[SPAWN POINT]Adding spawn point to game rules, Id = '%d'. Number of Spawn points = '%" PRISIZE_T "'", location, m_spawnLocations.size()); } stl::push_back_unique(m_allSpawnLocations, location); std::sort(m_allSpawnLocations.begin(), m_allSpawnLocations.end(), compare_spawns_name_only()); // We now rely on the order of the table to save memory by not binding spawn points to the network }
void CDLCManager::OnDLCMountFinished(int nPacksFound) { CryLog( "OnDLCMountFinished nPacksFound:%d", nPacksFound); CryLog( "DLC: Loaded DLCs flags are 0x%x", GetLoadedDLCs() ); if( nPacksFound > 0 ) { //we should rescan for any levels added by the DLCs ILevelSystem *pLevelSystem = g_pGame->GetIGameFramework()->GetILevelSystem(); pLevelSystem->Rescan("levels", ILevelSystem::TAG_MAIN); } #if ! ENTITLEMENTS_AUTHORATIVE //on consoles, after DLC is loaded, we know about what DLC is allowed m_allowedDLCUpToDate = true; #endif }
//------------------------------------------------------------------------ CGameRulesMPDamageHandling::CGameRulesMPDamageHandling() { CryLog("CGameRulesMPDamageHandling::CGameRulesMPDamageHandling()"); #ifdef SERVER_CHECKS m_checkCounter = 0; #endif m_localMeleeScreenFxTimer = 0.f; m_entityLastDamageUpdateTimer = 0.f; }
//------------------------------------------------------------------------ IMPLEMENT_RMI(CGameRules, ClHostMigrationPlayerJoined) { const EntityId playerId = params.entityId; #if !defined(_RELEASE) IEntity *pPlayer = gEnv->pEntitySystem->GetEntity(playerId); CryLog("CGameRules::ClHostMigrationPlayerJoined() '%s'", pPlayer ? pPlayer->GetName() : "<NULL>"); #endif // todo: ui return true; }
/// Registers a feature test (does not take ownership of test) void CFeatureTestMgr::RegisterFeatureTest(IFeatureTest* pFeatureTest) { assert(pFeatureTest); if (pFeatureTest) { if (!stl::push_back_unique(m_featureTests, pFeatureTest)) { CryLog("Feature test case already registered: %s", pFeatureTest->Name()); } } }
// static void CGameLobbyManager::UserSignoutCallback(CryLobbyTaskID taskID, ECryLobbyError error, void *pArg) { CryLog("UserSignoutCallback error %d", error); CGameLobbyManager *pLobbyMgr =(CGameLobbyManager*)pArg; if(pLobbyMgr && pLobbyMgr->m_signOutTaskID == taskID) { pLobbyMgr->m_signOutTaskID = CryLobbyInvalidTaskID; } }
void CWorldState::CreateChild(const char * entityName) { if(worldStateXml) { CryLog("CWorldState::CreateEntityChild()"); worldStateXml->newChild(entityName); worldStateXml->saveToFile(szSaveFile); } else return; }
// IConsoleVarSink bool CBatchSyncVarsSink::OnBeforeVarChange( ICVar *pVar,const char *sNewValue ) { #if LOG_CVAR_USAGE CryLog("[CVARS]: [CHANGED] CBatchSyncVarsSink::OnBeforeVarChange(): variable [%s] with a value of [%s]; %s changing to [%s]", pVar->GetName(), pVar->GetString(), (gEnv->bServer) ? "SERVER" : "CLIENT", sNewValue); #endif // LOG_CVAR_USAGE return true; }