C++ IEntitySystem::GetEntityIterator方法代码示例

	virtual void OnIterStart(SActivationInfo *pActInfo)
	{
		const int type = GetPortInt(pActInfo, EIP_Type);

		IEntitySystem *pEntitySystem = gEnv->pEntitySystem;
		if (pEntitySystem)
		{
			IEntityItPtr iter = pEntitySystem->GetEntityIterator();
			if (iter)
			{
				iter->MoveFirst();
				IEntity *pEntity = NULL;
				while (!iter->IsEnd())
				{
					pEntity = iter->Next();
					if (pEntity)
					{
						const EntityId id = pEntity->GetId();
						const EEntityType entityType = GetEntityType(id);
						if (IsValidType(type, entityType))
						{
							AddEntity(id);
						}
					}
				}
			}
		}
	}

void CCheckpointSystem::DeleteDynamicEntities()
{
	IEntitySystem *pEntitySystem = gEnv->pEntitySystem;
	IEntityItPtr pIt = pEntitySystem->GetEntityIterator();
	//////////////////////////////////////////////////////////////////////////
	pIt->MoveFirst();
	while (!pIt->IsEnd())
	{
		IEntity * pEntity = pIt->Next();
		uint32 nEntityFlags = pEntity->GetFlags();

		// Local player must not be deleted.
		if (nEntityFlags & ENTITY_FLAG_LOCAL_PLAYER)
			continue;

		if (nEntityFlags & ENTITY_FLAG_SPAWNED)
			pEntitySystem->RemoveEntity( pEntity->GetId() );
	}
	// Force deletion of removed entities.
	pEntitySystem->DeletePendingEntities();
	//////////////////////////////////////////////////////////////////////////

	// Reset entity pools
	pEntitySystem->GetIEntityPoolManager()->ResetPools(false);
}

//////////////////////////////////////////////////////////////////////////
//
// Allows the game code to write game-specific data into the minimap xml
// file on level export. Currently used to export data to StatsTool
//
//////////////////////////////////////////////////////////////////////////
bool CEditorGame::GetAdditionalMinimapData(XmlNodeRef output)
{
	string classes = g_pGameCVars->g_telemetryEntityClassesToExport;
	if(!classes.empty())
	{
		// additional data relating to StatsTool
		XmlNodeRef statsNode = output->findChild("StatsTool");
		if(!statsNode)
		{
			statsNode = GetISystem()->CreateXmlNode("StatsTool");
			output->addChild(statsNode);
		}
		else
		{
			statsNode->removeAllChilds();
		}

		// first build a list of entity classes from the cvar
		std::vector<IEntityClass*> interestingClasses;
		int curPos = 0;
		string currentClass = classes.Tokenize(",",curPos);
		IEntitySystem* pES = GetISystem()->GetIEntitySystem();
		if(IEntityClassRegistry* pClassReg = pES->GetClassRegistry())
		{
			while (!currentClass.empty())
			{
				if(IEntityClass* pClass = pClassReg->FindClass(currentClass.c_str()))
				{
					interestingClasses.push_back(pClass);
				}

				currentClass = classes.Tokenize(",",curPos);
			}
		}

		// now iterate through all entities and save the ones which match the classes
		if(interestingClasses.size() > 0)
		{
			IEntityItPtr it = pES->GetEntityIterator();
			while(IEntity* pEntity = it->Next())
			{
				if(stl::find(interestingClasses, pEntity->GetClass()))
				{
					XmlNodeRef entityNode = GetISystem()->CreateXmlNode("Entity");
					statsNode->addChild(entityNode);

					entityNode->setAttr("class", pEntity->GetClass()->GetName());
					Vec3 pos = pEntity->GetWorldPos();
					entityNode->setAttr("x", pos.x);
					entityNode->setAttr("y", pos.y);
					entityNode->setAttr("z", pos.z);
				}
			}
		}
	}

	return true;
}

void CBaseManager::Validate(BuildingGUID nGUID)
{
	ControllerList ValidateList;
	ControllerList::iterator itBuilding = m_ControllerList.begin();
	if (GUID_INVALID != nGUID)
	{
		// Find it
		itBuilding = m_ControllerList.find(nGUID);

		// Check if it is ready to be validated
		if (true == itBuilding->second->BeforeValidate())
			ValidateList[itBuilding->first] = itBuilding->second;
	}
	else
	{
		// Check all of them
		for (itBuilding; itBuilding != m_ControllerList.end(); itBuilding++)
		{
			if (true == itBuilding->second->BeforeValidate())
				ValidateList.insert(ControllerList::value_type(itBuilding->first,itBuilding->second));
		}
	}
	if (true == ValidateList.empty()) return; // Must have something to continue with

	// Look for new interfaces and tell them they now represent me
	IEntity *pEntity = NULL;
	IEntitySystem *pES = gEnv->pEntitySystem;
	IEntityItPtr pIt = pES->GetEntityIterator();
	while (false == pIt->IsEnd())
	{
		if (NULL != (pEntity = pIt->Next()))
		{
			// Check if it has a CNCBuilding property table and that it is
			//	interfacing this particular one
			IScriptTable *pTable;
			if (NULL != pEntity && NULL != (pTable = pEntity->GetScriptTable()))
			{
				// Get property table
				SmartScriptTable props, cncbuilding;
				if (true == pTable->GetValue("Properties", props) &&
					true == props->GetValue("CNCBuilding", cncbuilding))
				{
					// Extract and build GUID
					char const* szTeam = 0;
					char const* szClass = 0;
					cncbuilding->GetValue("Team", szTeam);
					cncbuilding->GetValue("Class", szClass);
					BuildingGUID GUID = g_D6Core->pBaseManager->GenerateGUID(szTeam, szClass);
					itBuilding = ValidateList.find(GUID);
					if (itBuilding != ValidateList.end())
						itBuilding->second->AddInterface(pEntity);
				}
			}
		}
	}

	// And finally, validate them all
	for (itBuilding = ValidateList.begin(); itBuilding != ValidateList.end(); itBuilding++)
	{
		itBuilding->second->Validate();
	}
}