自学教程：C++ CryLog函数代码示例

//------------------------------------------------------------------------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(&param, 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 datavoid 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;}

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

void CWorldState::CreateChild(const char * entityName){	if(worldStateXml)	{		CryLog("CWorldState::CreateEntityChild()");		worldStateXml->newChild(entityName);		worldStateXml->saveToFile(szSaveFile);	}	else		return;}

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