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

void CEntityAudioProxy::OnMove(){	CRY_ASSERT_MESSAGE(!(((m_nFlags & eEAPF_CAN_MOVE_WITH_ENTITY) > 0) && ((m_pEntity->GetFlagsExtended() & ENTITY_FLAG_EXTENDED_AUDIO_LISTENER) > 0)), "An CEntityAudioProxy cannot have both flags (eEAPF_CAN_MOVE_WITH_ENTITY & ENTITY_FLAG_EXTENDED_AUDIO_LISTENER) set simultaneously!");	Matrix34 const& tm = m_pEntity->GetWorldTM();	CRY_ASSERT_MESSAGE(tm.IsValid(), "Invalid Matrix34 during CEntityAudioProxy::OnMove");	if ((m_nFlags & eEAPF_CAN_MOVE_WITH_ENTITY) > 0)	{		std::for_each(m_mapAuxAudioProxies.begin(), m_mapAuxAudioProxies.end(), SRepositionAudioProxy(tm));	}	else if ((m_pEntity->GetFlagsExtended() & ENTITY_FLAG_EXTENDED_AUDIO_LISTENER) > 0)	{		Matrix34 position = tm;		position += CVar::audioListenerOffset;		if (!s_audioListenerLastTransformation.IsEquivalent(position, 0.01f))		{			s_audioListenerLastTransformation = position;			SAudioRequest oRequest;			oRequest.nFlags = eARF_PRIORITY_NORMAL;			oRequest.pOwner = this;			SAudioListenerRequestData<eALRT_SET_POSITION> oRequestData(s_audioListenerLastTransformation);			oRequest.pData = &oRequestData;			gEnv->pAudioSystem->PushRequest(oRequest);			// As this is an audio listener add its entity to the AreaManager for raising audio relevant events.			gEnv->pEntitySystem->GetAreaManager()->MarkEntityForUpdate(m_pEntity->GetId());		}	}}

/* static */bool CGameBrowser::CreatePresenceString(CryFixedStringT<MAX_PRESENCE_STRING_SIZE> &out, SCryLobbyUserData *pData, uint32 numData){	bool result = true;	if(numData > 0)	{		CRY_ASSERT_MESSAGE(pData[CGame::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[CGame::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:#ifdef GAME_IS_CRYSIS2			if(numData == 3)			{				const int gameModeId = pData[CGame::eRPT_Param1].m_int32;				const int mapId = pData[CGame::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#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 richpresence because numData was 0 or there was no hud");		result = false;	}	return result;}

//-------------------------------------------------void CHandGrenades::InitFireModes(){	inherited::InitFireModes();	int firemodeCount = m_firemodes.size();	m_pThrow = NULL;	int throwId = -1;	for(int i = 0; i < firemodeCount; i++)	{		if (crygti_isof<CThrow>(m_firemodes[i]))		{			CRY_ASSERT_MESSAGE(!m_pThrow, "Multiple Throw firemodes assigned to weapon");			m_pThrow = crygti_cast<CThrow*>(m_firemodes[i]);			throwId = i;		}	}	CRY_ASSERT_MESSAGE(m_pThrow, "No Throw firemode assigned to weapon");	if(m_pThrow)	{		SetCurrentFireMode(throwId);	}}

//------------------------------------------------------------------------void CVehicleViewSteer::UpdateView(SViewParams &viewParams, EntityId playerId){	static bool doUpdate = true;	if (!doUpdate) return;	if (m_position.IsValid())	{		viewParams.position = m_position;	}	else	{		CRY_ASSERT_MESSAGE(0, "camera position invalid");	}	Vec3 dir = (m_lookAt - m_position).GetNormalizedSafe();	if (dir.IsValid() && dir.GetLengthSquared() > 0.01f)	{		viewParams.rotation = Quat::CreateRotationVDir(dir);	}	else	{		CRY_ASSERT_MESSAGE(0, "camera rotation invalid");	}	// set view direction on actor	IActor* pActor = m_pSeat->GetPassengerActor(true);	if (pActor && pActor->IsClient())	{		pActor->SetViewInVehicle(viewParams.rotation);	}}

//-----------------------------------------------------------------------------------------------------void ScreenLayoutManager::SetState( ScreenLayoutStates flags ){	CRY_ASSERT_MESSAGE( !((flags&eSLO_ScaleMethod_None) && (flags&eSLO_ScaleMethod_WithY)), "HUD: Conflicting scale methods" );	CRY_ASSERT_MESSAGE( !((flags&eSLO_ScaleMethod_None) && (flags&eSLO_ScaleMethod_WithX)), "HUD: Conflicting scale methods" );	CRY_ASSERT_MESSAGE( !((flags&eSLO_ScaleMethod_WithY) && (flags&eSLO_ScaleMethod_WithX)), "HUD: Conflicting scale methods" );	m_flags = flags; // |=  /?}

void CFlowNode_AISequenceAction_WeaponHolster::HandleSequenceEvent(AIActionSequence::SequenceEvent sequenceEvent){	switch(sequenceEvent)	{	case AIActionSequence::StartAction:		{			CRY_ASSERT_MESSAGE(m_actInfo.pEntity, "entity has magically gone");			if (!m_actInfo.pEntity)			{				// the entity has gone for some reason, at least make sure the action gets finished properly and the FG continues				CancelSequenceAndActivateOutputPort(OutputPort_Done);				return;			}			assert(gEnv && gEnv->pGame && gEnv->pGame->GetIGameFramework() && gEnv->pGame->GetIGameFramework()->GetIActorSystem());			IActor* pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(m_actInfo.pEntity->GetId());			if (!pActor)			{				CRY_ASSERT_MESSAGE(0, "Provided entity must be an IActor");				CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Provided entity %s must be an IActor", m_actInfo.pEntity->GetName());				CancelSequenceAndActivateOutputPort(OutputPort_Done);				return;			}			const bool skipHolsterAnimation = GetPortBool(&m_actInfo, InputPort_SkipHolsterAnimation);			pActor->HolsterItem(true, !skipHolsterAnimation);			FinishSequenceActionAndActivateOutputPort(OutputPort_Done);		}		break;	}}

	void CEffectsController::InitWithEntity(IEntity *pEntity)	{		CRY_ASSERT_MESSAGE(pEntity, "Init Effect controller with NULL entity, this will crash!");		CRY_ASSERT_MESSAGE((m_pOwnerEntity == NULL), "Effect controller had already an entity assigned");		m_pOwnerEntity = pEntity;	}

void CActionScope::QueueAnimFromSequence(uint32 layer, uint32 pos, bool isPersistent){    CRY_ASSERT_MESSAGE(layer < m_numLayers, "Invalid layer idx");    SSequencer &sequencer = m_layerSequencers[layer];    if (pos < sequencer.sequence.size())    {        const SAnimClip &animClip = sequencer.sequence[pos];        const SAnimBlend &fragmentBlend = animClip.blend;        sequencer.blend = fragmentBlend;        sequencer.installTime   = sequencer.blend.exitTime;        if (pos > 0)        {            sequencer.referenceTime = sequencer.sequence[pos-1].referenceLength;        }        sequencer.flags |= eSF_Queued;        CRY_ASSERT_MESSAGE(sequencer.installTime >= 0.0f, "Invalid exit time!");    }    else if (!isPersistent)    {        if (pos > 0)        {            sequencer.referenceTime = sequencer.sequence[pos-1].referenceLength;        }        sequencer.installTime = sequencer.referenceTime;        sequencer.flags |= eSF_Queued;    }}

void CTacticalPointLanguageExtender::UnregisterFromTacticalPointSystem(){	CRY_ASSERT_MESSAGE(gEnv->pAISystem->GetTacticalPointSystem() != NULL, "Expecting tactical point system to exist, but it doesn't.");	ITacticalPointSystem& tacticalPointSystem = *gEnv->pAISystem->GetTacticalPointSystem();	bool successfullyRemovedLanguageExtender = tacticalPointSystem.RemoveLanguageExtender(this);	CRY_ASSERT_MESSAGE(successfullyRemovedLanguageExtender, "Failed to remove tactical point language extender.");}

CPlayerPlugin::~CPlayerPlugin(){	if (m_ownerPlayer)	{		CRY_ASSERT_MESSAGE(!m_entered, ("[PLAYER PLUG-IN] <%s %s /"%s/"> %s", m_ownerPlayer->IsClient() ? "Local" : "Remote", m_ownerPlayer->GetEntity()->GetClass()->GetName(), m_ownerPlayer->GetEntity()->GetName(), string().Format("Player plug-in is being destroyed without having been shut down cleanly!").c_str()));	}	else	{		CRY_ASSERT_MESSAGE(!m_entered, ("[PLAYER PLUG-IN] <NULL> %s", string().Format("Player plug-in is being destroyed without having been shut down cleanly!").c_str()));	}}

// message from server received on clientsvoid CVTOLVehicleManager::OnSingleEntityRMI(CGameRules::SModuleRMIEntityParams params){	switch(params.m_data)	{		case eRMITypeSingleEntity_vtol_destroyed:		{			CryLog("CVTOLVehicleManager::OnSingleEntityRMI() eRMITypeSingleEntity_vtol_destroyed");			IVehicle* pVehicle = m_pVehicleSystem->GetVehicle( params.m_entityId );			CRY_ASSERT_MESSAGE(pVehicle, "have received destroyed VTOL RMI, but cannot find the vehicle for specified entity id");			if (pVehicle)			{				DestroyVTOL(pVehicle->GetEntity(), m_vtolList[params.m_entityId]);			}			break;		}		case eRMITypeSingleEntity_vtol_hidden:				// for late joining clients only		{			CryLog("CVTOLVehicleManager::OnSingleEntityRMI() eRMITypeSingleEntity_vtol_hidden");			IVehicle* pVehicle = m_pVehicleSystem->GetVehicle(params.m_entityId);			CRY_ASSERT_MESSAGE(pVehicle, "have received hidden VTOL RMI, but cannot find the vehicle for specified entity id");			if (pVehicle)			{						//Hide existing vehicle				IEntity* pVehicleEntity = pVehicle->GetEntity();				pVehicleEntity->SetPos(Vec3(0.f,0.f,0.f));	// TODO - get Gary's fix for this if any				pVehicleEntity->Hide(true);				SVTOLInfo& info = m_vtolList[params.m_entityId];				info.state = EVS_Invisible;				info.stateTime = 0.f;		// this may allow clients to do their own respawn handling, stopping the need for respawned RMI below				SHUDEvent hudEvent(eHUDEvent_RemoveEntity);				hudEvent.AddData((int)params.m_entityId);				CHUDEventDispatcher::CallEvent(hudEvent);			}			break;		}		case eRMITypeSingleEntity_vtol_respawned:		{			CryLog("CVTOLVehicleManager::OnSingleEntityRMI() eRMITypeSingleEntity_vtol_respawned");			IVehicle* pVehicle = m_pVehicleSystem->GetVehicle(params.m_entityId);			CRY_ASSERT_MESSAGE(pVehicle, "have received respawned VTOL RMI, but cannot find the vehicle for specified entity id");			if (pVehicle)			{				RespawnVTOL(pVehicle, m_vtolList[params.m_entityId]);			}			break;		}		default:			CRY_ASSERT_MESSAGE(0, string().Format("unhandled RMI data %d", params.m_data));			break;	}}

CEntity* CEntityPool::GetEntityFromPool(bool &outIsActive, EntityId forcedPoolId /*= 0*/){	FUNCTION_PROFILER(GetISystem(), PROFILE_ENTITY);	CEntity* pPoolEntity = NULL;	if (forcedPoolId > 0)	{		pPoolEntity = GetPoolEntityWithPoolId(outIsActive, forcedPoolId);	}	if (!pPoolEntity)	{		pPoolEntity = GetPoolEntityFromInactiveSet();		if (pPoolEntity)			outIsActive = false;	}	if (!pPoolEntity)	{		pPoolEntity = GetPoolEntityFromActiveSet();		if (pPoolEntity)			outIsActive = true;	}	if (!pPoolEntity)	{		CRY_ASSERT_MESSAGE(false, "CEntityPool::GetEntityFromPool() Creating new entity for pool usage at run-time. Pool was too small!");		EntityWarning("[Entity Pool] Pool /'%s/' was too small. A new entity had to be created at run-time. Consider increasing the pool size.", m_sName.c_str());#ifdef ENTITY_POOL_DEBUGGING		m_bDebug_HasExpanded = true;#endif //ENTITY_POOL_DEBUGGING		// Make sure not to go above the max size		if (m_uMaxSize > 0 && m_InactivePoolIds.size() + m_ActivePoolIds.size() < m_uMaxSize)		{			// Make a new one			if (!CreatePoolEntity(pPoolEntity, false))			{				CRY_ASSERT_MESSAGE(false, "CEntityPool::GetEntityFromPool() Failed when creating a new pool entity.");			}		}		else		{			CRY_ASSERT_MESSAGE(false, "CEntityPool::GetEntityFromPool() Have to create a new pool entity but am already at max size!");			EntityWarning("[Entity Pool] Pool /'%s/' has reached its max size and a new entity was requested. The new entity was not created!", m_sName.c_str());		}		outIsActive = false;	}	return pPoolEntity;}

/* static */const char* CGameBrowser::GetGameModeStringFromId(int32 id){	char *strGameMode = NULL;	switch(id)	{#ifdef GAME_IS_CRYSIS2	case RICHPRESENCE_GAMEMODES_INSTANTACTION:		strGameMode = "@ui_rules_InstantAction";		break;	case RICHPRESENCE_GAMEMODES_TEAMINSTANTACTION:		strGameMode = "@ui_rules_TeamInstantAction";		break;	case RICHPRESENCE_GAMEMODES_ASSAULT:		strGameMode = "@ui_rules_Assault";		break;	case RICHPRESENCE_GAMEMODES_CAPTURETHEFLAG:		strGameMode = "@ui_rules_CaptureTheFlag";		break;	case RICHPRESENCE_GAMEMODES_EXTRACTION:		strGameMode = "@ui_rules_Extraction";		break;	case RICHPRESENCE_GAMEMODES_CRASHSITE:		strGameMode = "@ui_rules_CrashSite";		break;	case RICHPRESENCE_GAMEMODES_ALLORNOTHING:		strGameMode = "@ui_rules_AllOrNothing";		break;	case RICHPRESENCE_GAMEMODES_BOMBTHEBASE:		strGameMode = "@ui_rules_BombTheBase";		break;	case RICHPRESENCE_GAMEMODES_POWERSTRUGGLE:		strGameMode = "@ui_rules_PowerStruggleLite";		break;	default:		CRY_ASSERT_MESSAGE(false, "Failed to find game rules rich presence string");		break;	#else	case 0: //fallthrough to prevent warning	default:		CRY_ASSERT_MESSAGE(false, "Failed to find game rules rich presence string");		break;		}#endif	return strGameMode;}

void CFireMode::InitFireMode( IWeapon* pWeapon, const SParentFireModeParams* pParams){	CRY_ASSERT_MESSAGE(pParams, "Fire Mode Params NULL! Have you set up the weapon xml correctly?");	CRY_ASSERT_MESSAGE(pParams->pBaseFireMode, "Fire Mode Base Params NULL!");	m_pWeapon = static_cast<CWeapon *>(pWeapon);	m_fireParams = pParams->pBaseFireMode;	m_parentFireParams = pParams;	ResetParams();}

//----------------------------------------------------------void CSingleAllocTextBlock::Lock(){	CRY_ASSERT_MESSAGE(m_numBytesUsed == m_sizeNeeded, string().Format("Didn't fill entire block of reserved memory: allocated %d bytes, used %d", m_sizeNeeded, m_numBytesUsed));#if MORE_SINGLE_ALLOC_TEXT_BLOCK_CHECKS	CRY_ASSERT_MESSAGE(m_mem[m_sizeNeeded] == '@', "Memory overwrite");#endif	m_reuseDuplicatedStringsArray = NULL;	m_reuseDuplicatedStringsArraySize = 0;	m_reuseDuplicatedStringsNumUsed = 0;}

	bool LuaArgToUIArgImpl(T& t, int idx, TUIData &value)	{		bool bOk = false;		switch(GetVarType(t, idx))		{		case svtBool:			{				bool val;				bOk = GetVarValue(t, idx, val);				value = TUIData(val);			}			break;		case svtNumber:			{				float val;				bOk = GetVarValue(t, idx, val);				value = TUIData(val);			}			break;		case svtString:			{				const char* val;				bOk = GetVarValue(t, idx, val);				value = TUIData( string(val) );			}			break;		case svtObject:			{				Vec3 val(ZERO);				bOk = GetVarValue(t, idx, val);				value = TUIData(val);			}			break;		case svtPointer:			{				ScriptHandle sh;				bOk = GetVarValue(t, idx, sh);				value = TUIData((EntityId)sh.n);			}			break;		case svtNull:			CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");			break;		case svtUserData:			CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");			break;		case svtFunction:			CRY_ASSERT_MESSAGE(false, "Invalid data type for UIAction call!");			break;		}		return bOk;	}

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

void CFlashUIEventNode::FlushNextEvent( SActivationInfo* pActInfo ){	if (m_events.size() > 0)	{		const std::pair<SUIArguments, int> &data          = m_events.get();		const SUIArguments &                args          = data.first;		bool                                bTriggerEvent = true;		const int                           checkValue    = GetPortInt(pActInfo, eI_CheckPort);		if (checkValue >= 0)		{			bTriggerEvent = false;			CRY_ASSERT_MESSAGE(checkValue < args.GetArgCount(), "Port does not exist!" );			if (checkValue < args.GetArgCount())			{				string val = GetPortString(pActInfo, eI_CheckValue);				string compstr;				args.GetArg(checkValue).GetValueWithConversion(compstr);				bTriggerEvent = val == compstr;			}		}		if (bTriggerEvent)		{			int    end = m_eventDesc.InputParams.Params.size();			string val;			int i = 0;			for (; i < end; ++i)			{				CRY_ASSERT_MESSAGE( i < args.GetArgCount(), "UIEvent received wrong number of arguments!" );				ActivateDynOutput( i < args.GetArgCount() ? args.GetArg(i) : TUIData(string("")), m_eventDesc.InputParams.Params[i], pActInfo, i + 2 );			}			if (m_eventDesc.InputParams.IsDynamic)			{				SUIArguments dynarg;				for (; i < args.GetArgCount(); ++i)				{					if (args.GetArg( i, val ))						dynarg.AddArgument( val );				}				ActivateOutput( pActInfo, end + eO_DynamicPorts, string( dynarg.GetAsString()));			}			ActivateOutput( pActInfo, eO_OnEvent, true );			ActivateOutput( pActInfo, eO_OnInstanceId, data.second );		}		m_events.pop();	}}

void CDownloadableResource::SetDownloadInfo(const char* pUrl, const char* pUrlPrefix, const char* pServer, const int port, const int maxDownloadSize, const char* pDescName/*=NULL*/){	CRY_ASSERT(pUrl && pServer && maxDownloadSize>0);	CRY_ASSERT_MESSAGE(m_port==0,"You cannot call CDownloadableResource::SetDownloadInfo() twice on the same resource");		// not unless the code is strengthened anyway	CRY_ASSERT_MESSAGE(port!=0,"You cannot request a download from port 0");		// invalid generally, but also we use 0 as not initialized here	m_port = port;	m_maxDownloadSize = maxDownloadSize;	m_server = pServer;	m_descName = pDescName ? pDescName : pUrl;	m_urlPrefix = pUrlPrefix;	m_url = pUrl;}

void CUIManager::Init(){	CHUDEventDispatcher::SetUpEventListener();	SHUDEvent::InitDataStack();	m_pWarningManager = new CWarningsManager();	m_pOptions = new CProfileOptions();	m_pScreenLayoutMan = new ScreenLayoutManager();	m_p2DRendUtils = new C2DRenderUtils(m_pScreenLayoutMan);	m_pHudSilhouettes = new CHUDSilhouettes();	m_pCVars = new CUICVars();	m_pMOSystem = new CHUDMissionObjectiveSystem();	m_pCVars->RegisterConsoleCommandsAndVars();		IUIEventSystemFactory* pFactory = IUIEventSystemFactory::GetFirst();	while (pFactory)	{		TUIEventSystemPtr pGameEvent = pFactory->Create();		CRY_ASSERT_MESSAGE(pGameEvent != NULL, "Invalid IUIEventSystemFactory!");		const char* name = pGameEvent->GetTypeName();		TUIEventSystems::const_iterator it = m_EventSystems.find(name);		if(it == m_EventSystems.end())		{			m_EventSystems[name] = pGameEvent;		}		else		{			string str;			str.Format("IUIGameEventSystem /"%s/" already exists!", name);			CRY_ASSERT_MESSAGE(false, str.c_str());		}		pFactory = pFactory->GetNext();	}	TUIEventSystems::const_iterator it = m_EventSystems.begin();	TUIEventSystems::const_iterator end = m_EventSystems.end();	for (;it != end; ++it)	{		it->second->InitEventSystem();	}	InitSound();	gEnv->pSystem->GetISystemEventDispatcher()->RegisterListener( this );	g_pGame->GetIGameFramework()->RegisterListener(this, "CUIManager", FRAMEWORKLISTENERPRIORITY_HUD);	m_bRegistered = true;}

void CDamageEffectController::OnRevive() {	uint8 bitCheck = 1;	bool netSync = false;	for(int i = 0; i < MAX_NUM_DAMAGE_EFFECTS; i++)	{		if (m_activeEffectsBitfield & bitCheck)		{			netSync = true;			CRY_ASSERT_MESSAGE(m_effectList[i], "The effect should not be null if it is active");						m_effectList[i]->Leave();		}		bitCheck = bitCheck << 1;	}	m_activeEffectsBitfield = 0;	m_effectsKillBitfield = 0;	if (netSync)	{		CHANGED_NETWORK_STATE(m_ownerActor, eEA_GameServerDynamic);	}}

//----------------------------------------------------------const char * CSingleAllocTextBlock::StoreText(const char * textIn, bool doDuplicateCheck){	const char * reply = NULL;	if (textIn)	{		reply = doDuplicateCheck ? FindDuplicate(textIn) : NULL;		if (reply == NULL)		{			CRY_ASSERT_MESSAGE(m_mem != NULL, "No memory has been allocated!");			if (cry_strncpy(m_mem + m_numBytesUsed, textIn, m_sizeNeeded - m_numBytesUsed))			{				reply = m_mem + m_numBytesUsed;				m_numBytesUsed += strlen(reply) + 1;				if (doDuplicateCheck)				{					RememberPossibleDuplicate(reply);				}			}#ifndef _RELEASE			else			{				GameWarning("Tried to store too much text in a single-alloc text block of size %" PRISIZE_T " (%" PRISIZE_T " bytes have already been used, no room for '%s')", m_sizeNeeded, m_numBytesUsed, textIn);			}#endif		}		SingleAllocTextBlockLog ("Storing a copy of '%s', now used %u/%u bytes, %u bytes left", textIn, m_numBytesUsed, m_sizeNeeded, m_sizeNeeded - m_numBytesUsed);	}	CRY_ASSERT_TRACE (m_numBytesUsed <= m_sizeNeeded, ("Counters have been set to invalid values! Apparently used %d/%d bytes!", m_numBytesUsed, m_sizeNeeded));	return reply;}

//------------------------------------------------------------------------IUIElement* CScriptBind_UIAction::GetElement( const char* sName, int instanceID, bool bSupressWarning ){	if (gEnv->IsDedicated())		return NULL;	CRY_ASSERT_MESSAGE( gEnv->pFlashUI, "FlashUI extension does not exist!" );	if ( !gEnv->pFlashUI )	{		UIACTION_WARNING( "LUA: FlashUI extension does not exist!" );		return NULL;	}	IUIElement* pElement = gEnv->pFlashUI->GetUIElement( sName );	if ( pElement && instanceID > 0)		pElement = pElement->GetInstance( instanceID );	if (pElement && pElement->IsValid())		return pElement;	if (!bSupressWarning)	{		UIACTION_WARNING( "LUA: Try to access UIElement %s that is not valid!", sName );	}	return NULL;}

//------------------------------------------------------------------------------------bool CFlashUIAction::Serialize( XmlNodeRef& xmlNode, bool bIsLoading ){    CRY_ASSERT_MESSAGE(m_type == eUIAT_FlowGraph, "Try to serialize Flowgraph of Lua UI Action");    bool ok = m_pFlowGraph->SerializeXML( xmlNode, bIsLoading );    SetValid(ok);    return ok;}

void CGameLocalizationManager::LegacyLoadLocalizationData(){	// fallback to old system if localization.xml can not be found	GameWarning("Using Legacy localization loading");	ILocalizationManager *pLocMan = GetISystem()->GetLocalizationManager();	string const sLocalizationFolder(PathUtil::GetLocalizationFolder());	string const search(sLocalizationFolder + "*.xml");	ICryPak *pPak = gEnv->pCryPak;	_finddata_t fd;	intptr_t handle = pPak->FindFirst(search.c_str(), &fd);	if (handle > -1)	{		do		{			CRY_ASSERT_MESSAGE(stricmp(PathUtil::GetExt(fd.name), "xml") == 0, "expected xml files only");			string filename = sLocalizationFolder + fd.name;			pLocMan->LoadExcelXmlSpreadsheet(filename.c_str());		}		while (pPak->FindNext(handle, &fd) >= 0);		pPak->FindClose(handle);	}	else	{		GameWarning("Unable to find any Localization Data!");	}}