virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
case eFE_Activate:
{
IActorSystem *pActorSystem = gEnv->pGame->GetIGameFramework()->GetIActorSystem();
IActorIteratorPtr actorIt = pActorSystem->CreateActorIterator();
int iNumPlayers = 0;
IActor *pActor = actorIt->Next();
while(iNumPlayers < 4 && pActor)
{
if(pActor->GetChannelId())
{
ActivateOutput(pActInfo, iNumPlayers, pActor->GetEntityId());
++iNumPlayers;
}
pActor = actorIt->Next();
}
}
break;
}
}
void CHeavyWeapon::InitClient( int channelId )
{
BaseClass::InitClient(channelId);
IActor *pActor = GetOwnerActor();
if(pActor && pActor->GetChannelId() != channelId)
{
EntityId ownerId = pActor->GetEntityId();
GetGameObject()->InvokeRMIWithDependentObject(ClHeavyWeaponUsed(), SHeavyWeaponUserParams(ownerId), eRMI_ToClientChannel, ownerId, channelId);
}
else if(m_bIsHighlighted)
{
GetGameObject()->InvokeRMI(ClHeavyWeaponHighlighted(), SNoParams(), eRMI_ToClientChannel, channelId);
}
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
case eFE_Activate:
{
if(!pActInfo->pEntity)
ActivateOutput(pActInfo, 0, false);
else
{
CRY_ASSERT(gEnv->pGame);
IActor * pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pActInfo->pEntity->GetId());
if (pActor && pActor->GetChannelId() != 0) //is this a client ?
ActivateOutput(pActInfo, 0, true);
else
ActivateOutput(pActInfo, 0, false);
}
}
break;
}
}
//------------------------------------------------------------------------
void CGameRulesMPDamageHandling::Update(float frameTime)
{
FUNCTION_PROFILER(gEnv->pSystem, PROFILE_GAME);
float currentTime = gEnv->pTimer->GetCurrTime();
m_entityLastDamageUpdateTimer += frameTime;
if (m_entityLastDamageUpdateTimer > EntityCollisionLatentUpdateTimer)
{
m_entityLastDamageUpdateTimer = 0.0f;
if (!m_entityCollisionRecords.empty())
{
EntityCollisionRecords::iterator it = m_entityCollisionRecords.begin();
while (it != m_entityCollisionRecords.end())
{
const EntityCollisionRecord& record = it->second;
if ((record.time + EntityCollisionIgnoreTimeBetweenCollisions) < currentTime)
{
m_entityCollisionRecords.erase(it++);
}
else
{
++it;
}
}
}
}
UpdateKickableCarRecords(frameTime, currentTime);
if (gEnv->IsClient())
{
#ifndef _RELEASE
if (g_pGameCVars->pl_melee.mp_victim_screenfx_dbg_force_test_duration > 0.f)
{
m_localMeleeScreenFxTimer = (g_pGameCVars->pl_melee.mp_victim_screenfx_dbg_force_test_duration + g_pGameCVars->pl_melee.mp_victim_screenfx_blendout_duration);
g_pGameCVars->pl_melee.mp_victim_screenfx_dbg_force_test_duration = 0.f;
}
#endif
if (m_localMeleeScreenFxTimer > 0.f)
{
UpdateLocalMeleeScreenFx(frameTime);
}
}
#ifdef SERVER_CHECKS
//Iterate over unverified hits and see if there are any that haven't been assigned shots for X seconds
const float fCurrentTime = gEnv->pTimer->GetCurrTime();
int nNumUnverifiedHits = m_unverifiedList.size();
static const float kMaxTimeUnverified = 5.0f;
const float kDeleteUnverifiedBeforeThis = fCurrentTime - kMaxTimeUnverified;
for(int i = 0; i < nNumUnverifiedHits; i++)
{
const SUnverifiedFireData &rUnverifiedData = m_unverifiedList[i];
if(kDeleteUnverifiedBeforeThis > rUnverifiedData.fTime)
{
CGameRules * pGameRules = g_pGame->GetGameRules();
if(pGameRules)
{
IActor * pActor = pGameRules->GetActorByChannelId(rUnverifiedData.uChannelId);
if(pActor)
{
g_pGame->GetAntiCheatManager()->FlagActivity(eCT_HitShotIdMismatch, pActor->GetChannelId());
m_unverifiedList[i] = m_unverifiedList[nNumUnverifiedHits-1];
m_unverifiedList.pop_back();
nNumUnverifiedHits--;
i--;
}
}
}
}
static const float kMaxTimeVerifiedKept = 7.5f;
const float kDeleteVerifiedBeforeThis = fCurrentTime - kMaxTimeVerifiedKept;
//Iterate over shots and remove any that are too old
TShotHitVerificationMap::iterator iter = m_shotHitVerificationMap.begin();
while(iter != m_shotHitVerificationMap.end())
{
if(iter->second.fTime < kDeleteVerifiedBeforeThis)
{
TShotHitVerificationMap::iterator eraseIter = iter++;
m_shotHitVerificationMap.erase(eraseIter);
}
else
{
iter++;
}
}
#endif
}
//------------------------------------------------------------------------
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;
}
