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);
}
}
}
}
}
}
mono::object CScriptbind_Entity::GetEntitiesByClass(mono::string _class)
{
IEntityClass *pDesiredClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString(_class));
std::vector<EntityId> classEntities;
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
pIt->MoveFirst();
while(!pIt->IsEnd())
{
if(IEntity *pEntity = pIt->Next())
{
if(pEntity->GetClass() == pDesiredClass)
classEntities.push_back(pEntity->GetId());
}
}
if(classEntities.size()<1)
return nullptr;
IMonoClass *pEntityIdClass = g_pScriptSystem->GetCryBraryAssembly()->GetClass("EntityId");
IMonoArray *pArray = CreateMonoArray(classEntities.size());
for(auto it = classEntities.begin(); it != classEntities.end(); ++it)
pArray->Insert(pEntityIdClass->BoxObject(&mono::entityId(*it)));
return pArray->GetManagedObject();
}
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;
}
EContextEstablishTaskResult OnStep( SContextEstablishState& state )
{
bool allowPlayers = (m_what & eFS_Players) != 0;
bool allowGameRules = (m_what & eFS_GameRules) != 0;
bool allowOthers = (m_what & eFS_Others) != 0;
EntityId gameRulesId = 0;
if (IEntity * pGameRules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity())
gameRulesId = pGameRules->GetId();
// we are in the editor, and that means that there have been entities spawned already
// that are not bound to the network context... so lets bind them!
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
while (IEntity * pEntity = pIt->Next())
{
bool isOther = true;
bool isPlayer = false;
IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pEntity->GetId());
if (pActor && pActor->IsPlayer())
{
isPlayer = true;
isOther = false;
}
if (isPlayer && !allowPlayers)
continue;
bool isGameRules = false;
if (pEntity->GetId() == gameRulesId)
{
isGameRules = true;
isOther = false;
}
if (isGameRules && !allowGameRules)
continue;
if (isOther && !allowOthers)
continue;
CGameObject * pGO = (CGameObject *) pEntity->GetProxy( ENTITY_PROXY_USER );
if (pGO)
{
if (pGO->IsBoundToNetwork())
pGO->BindToNetwork(eBTNM_Force); // force rebinding
}
SEntitySpawnParams fakeParams;
fakeParams.id = pEntity->GetId();
fakeParams.nFlags = pEntity->GetFlags();
fakeParams.pClass = pEntity->GetClass();
fakeParams.qRotation = pEntity->GetRotation();
fakeParams.sName = pEntity->GetName();
fakeParams.vPosition = pEntity->GetPos();
fakeParams.vScale = pEntity->GetScale();
CCryAction::GetCryAction()->GetGameContext()->OnSpawn( pEntity, fakeParams );
}
return eCETR_Ok;
}
//------------------------------------------------------------------------
void CGameRules::HostMigrationFindDynamicEntities(TEntityIdVec &results)
{
IEntityItPtr pEntityIt = gEnv->pEntitySystem->GetEntityIterator();
while (IEntity *pEntity = pEntityIt->Next())
{
if (pEntity->GetFlags() & ENTITY_FLAG_NEVER_NETWORK_STATIC)
{
results.push_back(pEntity->GetId());
CryLog(" found dynamic entity %i '%s'", pEntity->GetId(), pEntity->GetName());
}
}
}
// for editor only
static void OnSysSpecLightChange( ICVar *pVar )
{
IEntityItPtr it = GetIEntitySystem()->GetEntityIterator();
it->MoveFirst();
while(IEntity *pEntity = it->Next())
{
IScriptTable *pScriptTable = pEntity->GetScriptTable();
if (pScriptTable && pScriptTable->HaveValue("OnSysSpecLightChanged"))
{
Script::CallMethod( pScriptTable, "OnSysSpecLightChanged" );
}
}
}
void CVar::DumpEntityClassesInUse(IConsoleCmdArgs * args)
{
IEntityItPtr it = GetIEntitySystem()->GetEntityIterator();
it->MoveFirst();
std::map<string, int> classes;
while(IEntity *pEntity = it->Next())
{
classes[pEntity->GetClass()->GetName()]++;
}
CryLogAlways("--------------------------------------------------------------------------------");
for (std::map<string, int>::iterator iter = classes.begin(); iter != classes.end(); ++iter)
CryLogAlways("%s: %d instances", iter->first.c_str(), iter->second);
}
EContextEstablishTaskResult OnStep( SContextEstablishState& state )
{
CScopedRemoveObjectUnlock unlockRemovals(CCryAction::GetCryAction()->GetGameContext());
if (m_skipGameRules || m_skipPlayers)
{
IEntityItPtr i = gEnv->pEntitySystem->GetEntityIterator();
while(!i->IsEnd())
{
IEntity* pEnt = i->Next();
// skip gamerules
if (m_skipGameRules)
if (pEnt->GetId() == CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity()->GetId())
continue;
// skip players
if (m_skipPlayers)
{
IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pEnt->GetId());
if (pActor && pActor->IsPlayer())
continue;
}
pEnt->ClearFlags(ENTITY_FLAG_UNREMOVABLE);
// force remove all other entities
gEnv->pEntitySystem->RemoveEntity(pEnt->GetId(), true);
}
if (!m_skipGameRules)
gEnv->pEntitySystem->ReserveEntityId(1);
}
else
{
if(!gEnv->pSystem->IsSerializingFile())
gEnv->pEntitySystem->Reset();
gEnv->pEntitySystem->ReserveEntityId(1);
}
gEnv->pEntitySystem->ReserveEntityId( LOCAL_PLAYER_ENTITY_ID );
CActionGame::Get()->OnEntitySystemReset();
return eCETR_Ok;
}
//------------------------------------------------------------------------
void CGameRules::HostMigrationFindDynamicEntities(TEntityIdVec &results)
{
IItemSystem *pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
IEntityItPtr pEntityIt = gEnv->pEntitySystem->GetEntityIterator();
while (IEntity *pEntity = pEntityIt->Next())
{
if (pEntity->GetFlags() & ENTITY_FLAG_NEVER_NETWORK_STATIC)
{
results.push_back(pEntity->GetId());
CryLog(" found dynamic entity %i '%s'", pEntity->GetId(), pEntity->GetName());
}
else
{
/*CItem *pItem = static_cast<CItem*>(pItemSystem->GetItem(pEntity->GetId()));
if (pItem)
{
// Need to reset owner on static items since they will be given to players again once we've rejoined
pItem->SetOwnerId(0);
}*/
}
}
}
mono::object CScriptbind_Entity::GetEntitiesByClasses(mono::object classes)
{
IMonoArray *pClassArray = *classes;
int numClasses = pClassArray->GetSize();
IEntityClass **pClasses = new IEntityClass *[numClasses];
for(int i = 0; i < numClasses; i++)
pClasses[i] = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString((mono::string)pClassArray->GetManagedObject()));
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");
IMonoArray *pEntities = CreateDynamicMonoArray();
pIt->MoveFirst();
while(!pIt->IsEnd())
{
if(IEntity *pEntity = pIt->Next())
{
IEntityClass *pEntityClass = pEntity->GetClass();
for(int i = 0; i < numClasses; i++)
{
if(pEntityClass == pClasses[i])
{
pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(pEntity->GetId())));
break;
}
}
}
}
auto result = pEntities->GetManagedObject();
pEntities->Release();
return result;
}
mono::object CScriptbind_Entity::GetEntitiesByClass(mono::string _class)
{
IEntityClass *pDesiredClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ToCryString(_class));
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
IMonoClass *pEntityIdClass = GetMonoScriptSystem()->GetCryBraryAssembly()->GetClass("EntityId");
IMonoArray *pEntities = CreateDynamicMonoArray();
pIt->MoveFirst();
while(!pIt->IsEnd())
{
if(IEntity *pEntity = pIt->Next())
{
if(pEntity->GetClass() == pDesiredClass)
pEntities->InsertMonoObject(pEntityIdClass->BoxObject(&mono::entityId(pEntity->GetId())));
}
}
auto result = pEntities->GetManagedObject();
pEntities->Release();
return result;
}
void CMPTutorial::Update()
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
if(!m_enabled && g_pGameCVars->g_PSTutorial_Enabled)
EnableTutorialMode(true);
else if(m_enabled && !g_pGameCVars->g_PSTutorial_Enabled)
EnableTutorialMode(false);
m_currentEvent.m_msgDisplayTime -= gEnv->pTimer->GetFrameTime();
if(!m_enabled)
{
if(m_currentEvent.m_msgDisplayTime < 0.0f && m_currentEvent.m_msgRemovalCondition != eMRC_None)
{
m_currentEvent.m_msgRemovalCondition = eMRC_None;
SAFE_HUD_FUNC(ShowTutorialText(NULL,1));
}
}
// update the text... must be done even if not enabled, to ensure the 'you may reenable...'
// message is shown correctly.
if(m_currentEvent.m_numChunks > 0)
{
// calculate how far through the current sound we are
CTimeValue now = gEnv->pTimer->GetFrameStartTime();
float soundTimer = now.GetMilliSeconds() - m_currentEvent.m_soundStartTime;
assert(soundTimer >= 0);
float soundPercent = 1.0f;
if(m_currentEvent.m_soundLength == 0.0f && m_currentEvent.m_pCurrentSound.get())
{
m_currentEvent.m_soundLength = m_currentEvent.m_pCurrentSound->GetLengthMs();
}
if(m_currentEvent.m_soundLength > 0.0f)
{
soundPercent = soundTimer / m_currentEvent.m_soundLength;
}
for(int i=m_currentEvent.m_numChunks-1; i > m_currentEvent.m_currentChunk; --i)
{
if(m_currentEvent.m_chunks[i].m_startPercent <= soundPercent)
{
m_currentEvent.m_currentChunk = i;
int pos = 2; // 2=bottom, 1=middle
IActor *pClientActor = g_pGame->GetIGameFramework()->GetClientActor();
if(pClientActor && pClientActor->GetLinkedVehicle())
{
pos = 1;
}
SAFE_HUD_FUNC(ShowTutorialText(m_currentEvent.m_chunks[i].m_text, pos));
break;
}
}
}
if(!m_enabled)
return;
CPlayer* pPlayer = static_cast<CPlayer*>(g_pGame->GetIGameFramework()->GetClientActor());
if(!pPlayer)
return;
// don't start until game begins
if(pPlayer->GetSpectatorMode() != 0 || g_pGame->GetGameRules()->GetCurrentStateId() != 3)
return;
if(!m_initialised)
{
m_initialised = true;
if(g_pGame->GetHUD())
{
// register as a HUD listener
g_pGame->GetHUD()->RegisterListener(this);
}
// go through entity list and pull out the factories.
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
while (!pIt->IsEnd())
{
if (IEntity * pEnt = pIt->Next())
{
if(pEnt->GetClass() == m_pHQClass)
{
m_baseList.push_back(pEnt->GetId());
//CryLog("Adding HQ %d to list: %d", pEnt->GetId(), m_baseList.size());
}
else if(pEnt->GetClass() == m_pAlienEnergyPointClass)
{
m_alienEnergyPointList.push_back(pEnt->GetId());
//CryLog("Adding AEP %d to list: %d", pEnt->GetId(), m_alienEnergyPointList.size());
}
else if(pEnt->GetClass() == m_pSpawnGroupClass)
{
m_spawnGroupList.push_back(pEnt->GetId());
//CryLog("Adding spawngroup %d to list: %d", pEnt->GetId(), m_spawnGroupList.size());
}
else if(pEnt->GetClass() == m_pFactoryClass)
{
m_factoryList.push_back(pEnt->GetId());
//CryLog("Adding Factory %d to list: %d", pEnt->GetId(), m_factoryList.size());
}
}
}
}
// first the briefing events. These are shown in order.
bool showPrompt = CheckBriefingEvents(pPlayer);
// player has been killed
if(pPlayer->GetHealth() <= 0)
{
showPrompt = TriggerEvent(eTE_Killed);
}
else if(!showPrompt)
{
// check each event type here. Which might take a while.
// entering a neutral factory
// enter prototype factory
// enter hostile factory
// find alien crash
m_entityCheckTimer -= gEnv->pTimer->GetFrameTime();
if(m_entityCheckTimer < 0.0f)
{
CheckNearbyEntities(pPlayer);
m_entityCheckTimer = ENTITY_CHECK_TIME;
}
// board vehicle and vehicle tutorials
CheckVehicles(pPlayer);
// player has been wounded
if(pPlayer->GetHealth() < pPlayer->GetMaxHealth())
TriggerEvent(eTE_Wounded);
// bases
m_baseCheckTimer -= gEnv->pTimer->GetFrameTime();
if(m_baseCheckTimer < 0.0f)
{
CheckBases(pPlayer);
m_baseCheckTimer = ENTITY_CHECK_TIME;
}
}
bool promptShown = false;
for(int i=0; i<eTE_NumEvents; ++i)
{
if(m_events[i].m_status == eMS_Waiting)
{
if(m_currentEvent.m_msgDisplayTime < -MESSAGE_GAP_TIME)
{
ShowMessage(m_events[i]);
}
promptShown = true;
break;
}
}
if(!promptShown && (m_currentEvent.m_msgRemovalCondition == eMRC_Time) && (m_currentEvent.m_msgDisplayTime < 0.0f))
{
HideMessage();
}
}
virtual void OnPostUpdate(float fDeltaTime)
{
// Get it once, then unregister to prevent unnescessary updates
if(!m_get)
{
gEnv->pGame->GetIGameFramework()->UnregisterListener(this);
return;
}
m_get = false;
// Grab the container, and make sure its valid (user has to create it for us and pass the valid ID)
IFlowSystemContainerPtr pContainer = gEnv->pFlowSystem->GetContainer(GetPortInt(&m_actInfo, EIP_ContainerId));
if(!pContainer)
return;
IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
while (!pIt->IsEnd())
{
if (IEntity *pEntity = pIt->Next())
{
//skip Local player
if (IPhysicalEntity *physEnt = pEntity->GetPhysics())
{
IActor *pClientActor = gEnv->pGame->GetIGameFramework()->GetClientActor();
if (!pClientActor)
return;
//skip the client actor entity
if (physEnt == pClientActor->GetEntity()->GetPhysics())
continue;
AABB worldBounds;
pEntity->GetWorldBounds(worldBounds);
//skip further calculations if the entity is not visible at all...
if (gEnv->pSystem->GetViewCamera().IsAABBVisible_F(worldBounds) == CULL_EXCLUSION)
continue;
Vec3 wpos = pEntity->GetWorldPos();
Quat rot = pEntity->GetWorldRotation();
AABB localBounds;
pEntity->GetLocalBounds(localBounds);
//get min and max values of the entity bounding box (local positions)
Vec3 points[2];
points[0] = wpos + rot * localBounds.min;
points[1] = wpos + rot * localBounds.max;
Vec3 pointsProjected[2];
//project the bounding box min max values to screen positions
for (int i=0; i<2; ++i)
{
gEnv->pRenderer->ProjectToScreen(points[i].x, points[i].y, points[i].z, &pointsProjected[i].x, &pointsProjected[i].y, &pointsProjected[i].z);
const float fWidth = (float)gEnv->pRenderer->GetWidth();
const float fHeight = (float)gEnv->pRenderer->GetHeight();
//scale projected values to the actual screen resolution
pointsProjected[i].x *= 0.01f * fWidth;
pointsProjected[i].y *= 0.01f * fHeight;
}
//check if the projected bounding box min max values are fully or partly inside the screen selection
if ((m_screenX <= pointsProjected[0].x && pointsProjected[0].x <= m_screenX2) ||
(m_screenX >= pointsProjected[0].x && m_screenX2 <= pointsProjected[1].x) ||
(m_screenX <= pointsProjected[1].x && m_screenX2 >= pointsProjected[1].x) ||
(m_screenX <= pointsProjected[0].x && m_screenX2 >= pointsProjected[1].x))
{
if ((m_screenY <= pointsProjected[0].y && m_screenY2 >= pointsProjected[0].y) ||
(m_screenY <= pointsProjected[1].y && m_screenY2 >= pointsProjected[0].y) ||
(m_screenY <= pointsProjected[1].y && m_screenY2 >= pointsProjected[1].y))
{
// Add entity to container
pContainer->AddItem(TFlowInputData(pEntity->GetId()));
}
}
}
}
}
}
//------------------------------------------------------------------------
bool CGameRules::OnPromoteToServer(SHostMigrationInfo& hostMigrationInfo, uint32& state)
{
if (!g_pGame->GetIGameFramework()->ShouldMigrateNub(hostMigrationInfo.m_session))
{
return true;
}
CryLogAlways("[Host Migration]: CGameRules::OnPromoteToServer() started");
// Server time will change after we migrate (change from old server time to new server time)
m_gameStartedTime.SetValue(m_gameStartedTime.GetValue() - m_cachedServerTime.GetValue());
m_gameStartTime.SetValue(m_gameStartTime.GetValue() - m_cachedServerTime.GetValue());
// If this migration has reset (we're not the original anticipated host, remove any entities from the first attempt
if (!m_hostMigrationCachedEntities.empty())
{
HostMigrationRemoveDuplicateDynamicEntities();
}
// Now we know we're the server, remove the actors for anyone we know isn't going to migrate
CGameLobby *pGameLobby = g_pGame->GetGameLobby();
CRY_ASSERT(pGameLobby);
if (pGameLobby)
{
TPlayers playersToRemove;
IActorSystem *pActorSystem = g_pGame->GetIGameFramework()->GetIActorSystem();
playersToRemove.reserve(pActorSystem->GetActorCount());
IActorIteratorPtr actorIt = pActorSystem->CreateActorIterator();
IActor *pActor;
while (pActor = actorIt->Next())
{
if (pActor->IsPlayer())
{
CRY_ASSERT(pActor->GetChannelId());
SCryMatchMakingConnectionUID conId = pGameLobby->GetConnectionUIDFromChannelID((int) pActor->GetChannelId());
if (pGameLobby->GetSessionNames().Find(conId) == SSessionNames::k_unableToFind)
{
CryLog(" player '%s' has not got a corresponding CGameLobby entry, removing actor", pActor->GetEntity()->GetName());
playersToRemove.push_back(pActor->GetEntityId());
}
}
}
const int numPlayersToRemove = playersToRemove.size();
for (int i = 0; i < numPlayersToRemove; ++ i)
{
FakeDisconnectPlayer(playersToRemove[i]);
}
}
for (uint32 i = 0; i < MAX_PLAYERS; ++ i)
{
m_migratedPlayerChannels[i] = 0;
}
IItemSystem *pItemSystem = g_pGame->GetIGameFramework()->GetIItemSystem();
IEntityItPtr it = gEnv->pEntitySystem->GetEntityIterator();
it->MoveFirst();
for (uint32 i = 0; i < m_hostMigrationItemMaxCount; ++ i)
{
m_pHostMigrationItemInfo[i].Reset();
}
uint32 itemIndex = 0;
IEntity *pEntity = NULL;
while (pEntity = it->Next())
{
IItem *pItem = pItemSystem->GetItem(pEntity->GetId());
if (pItem)
{
if (pItem->GetOwnerId())
{
IEntity *pOwner = gEnv->pEntitySystem->GetEntity(pItem->GetOwnerId());
if (pOwner)
{
EntityId currentItemId = 0;
IActor *pOwnerActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pOwner->GetId());
if (pOwnerActor)
{
IItem *pCurrentItem = pOwnerActor->GetCurrentItem();
currentItemId = pCurrentItem ? pCurrentItem->GetEntityId() : 0;
}
CryLog("[CG] Item '%s' is owned by '%s'", pEntity->GetName(), pOwner->GetName());
//m_pHostMigrationItemInfo[itemIndex].Set(pEntity->GetId(), pOwner->GetId(), pItem->IsUsed(), (pItem->GetEntityId() == currentItemId));
itemIndex ++;
if (itemIndex >= m_hostMigrationItemMaxCount)
{
CRY_ASSERT(itemIndex < m_hostMigrationItemMaxCount);
break;
}
}
}
}
// Tell entities that we're host migrating
// - Currently only used by ForbiddenArea but may well be needed for other entities later
// - Currently only called on the new server, add to OnDemoteToClient if we need to use this on a client
IScriptTable *pScript = pEntity->GetScriptTable();
if (pScript != NULL && pScript->GetValueType("OnHostMigration") == svtFunction)
{
m_pScriptSystem->BeginCall(pScript, "OnHostMigration");
m_pScriptSystem->PushFuncParam(pScript);
m_pScriptSystem->PushFuncParam(true);
m_pScriptSystem->EndCall();
}
}
// This needs initialising on the new server otherwise the respawn timer will be counting down
// from uninitialised data. Likewise for the pre-round timer.
ResetReviveCycleTime();
const int numRespawnParams = m_respawndata.size();
for (int i = 0; i < numRespawnParams; ++ i)
{
SEntityRespawnData *pData = &m_respawndata[i];
pEntity = gEnv->pEntitySystem->GetEntity(pData->m_currentEntityId);
if (pEntity == NULL)
{
CryLog(" detected respawn entity (id=%u) is not present, scheduling for respawn", pData->m_currentEntityId);
ScheduleEntityRespawn(pData->m_currentEntityId, false, g_pGameCVars->g_defaultItemRespawnTimer);
}
}
CryLog("[Host Migration]: CGameRules::OnPromoteToServer() finished");
CCCPOINT(HostMigration_OnPromoteToServer);
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();
}
}
//------------------------------------------------------------------------
bool CGameRules::OnPromoteToServer(SHostMigrationInfo &hostMigrationInfo, uint32 &state)
{
if (!g_pGame->GetIGameFramework()->ShouldMigrateNub(hostMigrationInfo.m_session))
{
return true;
}
CryLogAlways("[Host Migration]: CGameRules::OnPromoteToServer() started");
// Server time will change after we migrate (change from old server time to new server time)
m_gameStartedTime.SetValue(m_gameStartedTime.GetValue() - m_cachedServerTime.GetValue());
m_gameStartTime.SetValue(m_gameStartTime.GetValue() - m_cachedServerTime.GetValue());
// If this migration has reset (we're not the original anticipated host, remove any entities from the first attempt
if (!m_hostMigrationCachedEntities.empty())
{
HostMigrationRemoveDuplicateDynamicEntities();
}
for (uint32 i = 0; i < MAX_PLAYERS; ++ i)
{
m_migratedPlayerChannels[i] = 0;
}
IEntityItPtr it = gEnv->pEntitySystem->GetEntityIterator();
it->MoveFirst();
for (uint32 i = 0; i < m_hostMigrationItemMaxCount; ++ i)
{
m_pHostMigrationItemInfo[i].Reset();
}
uint32 itemIndex = 0;
IEntity *pEntity = NULL;
// Tell entities that we're host migrating
// - Currently only used by ForbiddenArea but may well be needed for other entities later
// - Currently only called on the new server, add to OnDemoteToClient if we need to use this on a client
IScriptTable *pScript = pEntity->GetScriptTable();
if (pScript != NULL && pScript->GetValueType("OnHostMigration") == svtFunction)
{
m_pScriptSystem->BeginCall(pScript, "OnHostMigration");
m_pScriptSystem->PushFuncParam(pScript);
m_pScriptSystem->PushFuncParam(true);
m_pScriptSystem->EndCall();
}
// This needs initialising on the new server otherwise the respawn timer will be counting down
// from uninitialised data. Likewise for the pre-round timer.
ResetReviveCycleTime();
// the server does not listen for entity_event_done, clients do however, when we migrate
// the new server needs to remove any of these events he may be listening for
TEntityTeamIdMap::iterator entityTeamsIt = m_entityteams.begin();
for (; entityTeamsIt != m_entityteams.end(); ++ entityTeamsIt)
{
EntityId entityId = entityTeamsIt->first;
RemoveEntityEventDoneListener(entityId);
#if !defined(_RELEASE)
IEntity *pTeamEntity = gEnv->pEntitySystem->GetEntity(entityId);
CryLog("[GameRules] OnPromoteToServer RemoveEntityEventLister(%d(%s), ENTITY_EVENT_DONE, %p)", entityId,
pTeamEntity ? pTeamEntity->GetName() : "null",
this);
#endif
}
ClearRemoveEntityEventListeners();
const int numRespawnParams = m_respawndata.size();
for (int i = 0; i < numRespawnParams; ++ i)
{
SEntityRespawnData *pData = &m_respawndata[i];
pEntity = gEnv->pEntitySystem->GetEntity(pData->m_currentEntityId);
if (pEntity == NULL)
{
CryLog(" detected respawn entity (id=%u) is not present, scheduling for respawn", pData->m_currentEntityId);
ScheduleEntityRespawn(pData->m_currentEntityId, false, g_pGameCVars->g_defaultItemRespawnTimer);
}
}
CryLog("[Host Migration]: CGameRules::OnPromoteToServer() finished");
CCCPOINT(HostMigration_OnPromoteToServer);
return true;
}
