bool CVisibleObjectsHelper::CheckObjectViewDist(const Agent& agent, const SVisibleObject &visibleObject) const { FUNCTION_PROFILER(GetISystem(), PROFILE_GAME); assert(agent.IsValid()); bool bInViewDist = true; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); IEntity *pAIEntity = pEntitySystem->GetEntity(agent.GetEntityID()); IEntity *pObjectEntity = pEntitySystem->GetEntity(visibleObject.entityId); IComponentRender *pObjectRenderProxy = (pAIEntity != NULL && pObjectEntity ? static_cast<IComponentRender *>(pObjectEntity->GetComponent<IComponentRender>().get()) : NULL); if (pObjectRenderProxy != NULL) { IRenderNode *pObjectRenderNode = pObjectRenderProxy->GetRenderNode(); if (pObjectRenderNode != NULL) { const float fDistanceSq = pAIEntity->GetWorldPos().GetSquaredDistance(pObjectEntity->GetWorldPos()); const float fMaxViewDistSq = sqr(pObjectRenderNode->GetMaxViewDist()); bInViewDist = (fDistanceSq <= fMaxViewDistSq); } } return bInViewDist; }
int CScriptBind_Action::GetPlayerList( IFunctionHandler *pH ) { CGameServerNub * pNub = m_pCryAction->GetGameServerNub(); if (!pNub) { GameWarning("No game server nub"); return pH->EndFunction(); } TServerChannelMap *playerMap = m_pCryAction->GetGameServerNub()->GetServerChannelMap(); if (!playerMap) return pH->EndFunction(); IEntitySystem *pES = gEnv->pEntitySystem; int k=1; SmartScriptTable playerList(m_pSS); for (TServerChannelMap::iterator it = playerMap->begin(); it != playerMap->end(); it++) { EntityId playerId = it->second->GetPlayerId(); if (!playerId) continue; IEntity *pPlayer = pES->GetEntity(playerId); if (!pPlayer) continue; if (pPlayer->GetScriptTable()) playerList->SetAt(k++, pPlayer->GetScriptTable()); } return pH->EndFunction(*playerList); }
//------------------------------------------------------------------------ int CInventory::FindPrev(IEntityClass *pClass, const char *category, int firstSlot, bool wrap) const { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; for (int i = (firstSlot > -1)?firstSlot+1:0; i < m_stats.slots.size(); i++) { IEntity *pEntity = pEntitySystem->GetEntity(m_stats.slots[firstSlot-i]); bool ok=true; if (pEntity->GetClass() != pClass) ok=false; if (ok && category && category[0] && strcmp(m_pGameFrameWork->GetIItemSystem()->GetItemCategory(pEntity->GetClass()->GetName()), category)) ok=false; if (ok) return i; } if (wrap && firstSlot > 0) { int count = GetCount(); for (int i = 0; i < firstSlot; i++) { IEntity *pEntity = pEntitySystem->GetEntity(m_stats.slots[count-i+firstSlot]); bool ok=true; if (pEntity->GetClass() != pClass) ok=false; if (ok && category && category[0] && strcmp(m_pGameFrameWork->GetIItemSystem()->GetItemCategory(pEntity->GetClass()->GetName()), category)) ok=false; if (ok) return i; } } return -1; }
void CDialogActorContext::BeginSession() { DiaLOG::Log(DiaLOG::eAlways, "[DIALOG] CDialogActorContext::BeginSession: %s Now=%f 0x%p actorID=%d ", m_pSession->GetDebugName(), m_pSession->GetCurTime(), this, m_actorID); ResetState(); IEntitySystem* pES = gEnv->pEntitySystem; pES->AddEntityEventListener( m_entityID, ENTITY_EVENT_AI_DONE, this ); pES->AddEntityEventListener( m_entityID, ENTITY_EVENT_DONE, this ); pES->AddEntityEventListener( m_entityID, ENTITY_EVENT_RESET, this ); switch (GetAIBehaviourMode()) { case CDialogSession::eDIB_InterruptAlways: ExecuteAI( m_goalPipeID, "ACT_ANIM" ); break; case CDialogSession::eDIB_InterruptMedium: ExecuteAI( m_goalPipeID, "ACT_DIALOG" ); break; case CDialogSession::eDIB_InterruptNever: break; } m_bNeedsCancel = true; }
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 CInventory::Destroy() { // //CryLog("%s::CInventory::Destroy()",GetEntity()->GetName()); // if(!GetISystem()->IsSerializingFile()) { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; IItemSystem *pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem(); TInventoryVector deleteList = m_stats.slots; for (TInventoryIt it = deleteList.begin(); it != deleteList.end(); ++it) { EntityId entityId = *it; IItem *pItem = pItemSystem->GetItem(entityId); if (pItem) { RemoveItemFromCategorySlot(pItem->GetEntityId()); pItem->RemoveOwnerAttachedAccessories(); pItem->AttachToHand(false); pItem->AttachToBack(false); pItem->SetOwnerId(0); } pEntitySystem->RemoveEntity(entityId); } } Clear(); }
//------------------------------------------------------------------------ int CInventory::Validate() { TInventoryVector copyOfSlots; copyOfSlots.reserve(m_stats.slots.size()); std::swap(copyOfSlots, m_stats.slots); int count = 0; const int slotCount = copyOfSlots.size(); IEntitySystem *pEntitySystem = gEnv->pEntitySystem; for (int i = 0; i < slotCount; ++i) { EntityId itemId = copyOfSlots[i]; IEntity *pEntity = pEntitySystem->GetEntity(itemId); if (!pEntity) { ++count; } else { m_stats.slots.push_back(itemId); } } return count; }
//------------------------------------------------------------------------ int CInventory::GetCountOfClass(const char *className) const { int count = 0; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; IEntityClass* pClass = (className != NULL) ? pEntitySystem->GetClassRegistry()->FindClass( className ) : NULL; if (pClass) { for (TInventoryCIt it = m_stats.slots.begin(); it != m_stats.slots.end(); ++it) { IEntity *pEntity = pEntitySystem->GetEntity(*it); if ((pEntity != NULL) && (pEntity->GetClass() == pClass)) { ++count; } } TInventoryVectorEx::const_iterator endEx = m_stats.accessorySlots.end(); for (TInventoryVectorEx::const_iterator cit = m_stats.accessorySlots.begin(); cit!=endEx; ++cit) { if (*cit == pClass) { count++; } } } return count; }
//------------------------------------------------------------------------ bool CVehicleActionEntityAttachment::DetachEntity() { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); if(IEntity *pEntity = pEntitySystem->GetEntity(m_entityId)) { IVehicleSystem *pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem(); assert(pVehicleSystem); // FIXME: remove this workaround, replace by e.g. buddy constraint if(IVehicle *pVehicle = pVehicleSystem->GetVehicle(m_entityId)) { int hitType = g_pGame->GetGameRules()->GetHitTypeId("disableCollisions"); pVehicle->OnHit(m_pVehicle->GetEntityId(), m_pVehicle->GetEntityId(), 10.0f, Vec3(0.0f, 0.0f, 0.0f), 0.0f, hitType, false); } pEntity->DetachThis(); m_isAttached = false; m_timer = g_parachuteTimeMax; m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate); return true; } return false; }
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); }
//------------------------------------------------------------------------ void CVehicleDamageBehaviorDetachPart::Reset() { if (m_detachedEntityId) { for(TDetachedStatObjs::iterator ite = m_detachedStatObjs.begin(), end = m_detachedStatObjs.end(); ite != end; ++ite) { CVehiclePartBase *pPartBase = ite->first; if(IStatObj *pStatObj = ite->second) { if(pPartBase) { pPartBase->SetStatObj(pStatObj); } pStatObj->Release(); } } m_detachedStatObjs.clear(); if(GetISystem()->IsSerializingFile() != 1) { IEntitySystem* pEntitySystem = gEnv->pEntitySystem; pEntitySystem->RemoveEntity(m_detachedEntityId, true); } m_detachedEntityId = 0; } }
//------------------------------------------------------------------------ void CVehicleActionEntityAttachment::SpawnEntity() { IEntitySystem* pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); IEntityClassRegistry* pClassRegistry = pEntitySystem->GetClassRegistry(); assert(pClassRegistry); IEntityClass* pEntityClass = pClassRegistry->FindClass(m_entityClassName.c_str()); if (!pEntityClass) return; char pEntityName[256]; _snprintf(pEntityName, 256, "%s_%s", m_pVehicle->GetEntity()->GetName(), m_entityClassName.c_str()); pEntityName[sizeof(pEntityName)-1] = '\0'; SEntitySpawnParams params; params.sName = pEntityName; params.nFlags = ENTITY_FLAG_CLIENT_ONLY; params.pClass = pEntityClass; IEntity* pEntity = pEntitySystem->SpawnEntity(params, true); if (!pEntity) { m_entityId = 0; return; } m_entityId = pEntity->GetId(); m_pVehicle->GetEntity()->AttachChild(pEntity); pEntity->SetLocalTM(m_pHelper->GetVehicleTM()); m_isAttached = true; }
EEntityType GetEntityType(EntityId id) { int type = eET_Unknown; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; if (pEntitySystem) { IEntity *pEntity = pEntitySystem->GetEntity(id); if (pEntity) { type = eET_Valid; IEntityClass *pClass = pEntity->GetClass(); if (pClass) { const char* className = pClass->GetName(); // Check AI if (pEntity->GetAI()) { type |= eET_AI; } // Check actor IActorSystem *pActorSystem = gEnv->pGame->GetIGameFramework()->GetIActorSystem(); if (pActorSystem) { IActor *pActor = pActorSystem->GetActor(id); if (pActor) { type |= eET_Actor; } } // Check vehicle IVehicleSystem *pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem(); if (pVehicleSystem) { if (pVehicleSystem->IsVehicleClass(className)) { type |= eET_Vehicle; } } // Check item IItemSystem *pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem(); if (pItemSystem) { if (pItemSystem->IsItemClass(className)) { type |= eET_Item; } } } } } return (EEntityType)type; }
////////////////////////////////////////////////////////////////////////// // // 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; }
virtual void DestroyGameObject( const char* name ) { IEntitySystem* pEntitySystem = PerModuleInterface::g_pSystemTable->pEntitySystem; IAUEntity* pEnt = pEntitySystem->Get(name); if (pEnt) { DestroyGameObject( pEnt->GetObject()->GetObjectId() ); } }
//CGameRules::IHitInfo virtual void OnHit(const HitInfo &hitInfo) { if(GetPortBool(&m_actInfo, EIP_Enable) == false) return; EntityId shooter = GetPortEntityId(&m_actInfo, EIP_ShooterId); if(shooter != 0 && shooter != hitInfo.shooterId) return; EntityId target = GetPortEntityId(&m_actInfo, EIP_TargetId); if(target != 0 && target != hitInfo.targetId) return; IEntitySystem *pEntitySys = gEnv->pEntitySystem; IEntity *pTempEntity; // check weapon match const string &weapon = GetPortString(&m_actInfo, EIP_Weapon); if(weapon.empty() == false) { pTempEntity = pEntitySys->GetEntity(hitInfo.weaponId); if(pTempEntity == 0 || weapon.compare(pTempEntity->GetClass()->GetName()) != 0) return; } // check ammo match const string &ammo = GetPortString(&m_actInfo, EIP_Ammo); if(ammo.empty() == false) { pTempEntity = pEntitySys->GetEntity(hitInfo.projectileId); if(pTempEntity == 0 || ammo.compare(pTempEntity->GetClass()->GetName()) != 0) return; } ActivateOutput(&m_actInfo, EOP_ShooterId, hitInfo.shooterId); ActivateOutput(&m_actInfo, EOP_TargetId, hitInfo.targetId); ActivateOutput(&m_actInfo, EOP_WeaponId, hitInfo.weaponId); ActivateOutput(&m_actInfo, EOP_ProjectileId, hitInfo.projectileId); ActivateOutput(&m_actInfo, EOP_HitPos, hitInfo.pos); ActivateOutput(&m_actInfo, EOP_HitDir, hitInfo.dir); ActivateOutput(&m_actInfo, EOP_HitNormal, hitInfo.normal); ActivateOutput(&m_actInfo, EOP_Damage, hitInfo.damage); ISurfaceType *pSurface = g_pGame->GetGameRules()->GetHitMaterial(hitInfo.material); ActivateOutput(&m_actInfo, EOP_Material, string(pSurface ? pSurface->GetName() : "")); const char *hitType = ""; if(CGameRules *pGR = g_pGame->GetGameRules()) hitType = pGR->GetHitType(hitInfo.type); ActivateOutput(&m_actInfo, EOP_HitType, string(hitType)); }
//------------------------------------------------------------------------ CVehicleActionEntityAttachment::~CVehicleActionEntityAttachment() { if(m_entityId) { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); pEntitySystem->RemoveEntity(m_entityId); } }
bool CDialogActorContext::ExecuteAI(int& goalPipeID, const char* signalText, IAISignalExtraData* pExtraData, bool bRegisterAsListener) { IEntitySystem* pSystem = gEnv->pEntitySystem; IEntity* pEntity = pSystem->GetEntity(m_entityID); if (pEntity == 0) return false; IAIObject* pAI = pEntity->GetAI(); if (pAI == 0) return false; unsigned short nType=pAI->GetAIType(); if ( nType != AIOBJECT_ACTOR ) { if ( nType == AIOBJECT_PLAYER ) { goalPipeID = -1; // not needed for player // pAI->SetSignal( 10, signalText, pEntity, NULL ); // 10 means this signal must be sent (but sent[!], not set) // even if the same signal is already present in the queue return true; } // invalid AIObject type return false; } IPipeUser* pPipeUser = pAI->CastToIPipeUser(); if (pPipeUser) { if (goalPipeID > 0) { pPipeUser->RemoveSubPipe(goalPipeID, true); pPipeUser->UnRegisterGoalPipeListener( this, goalPipeID ); goalPipeID = 0; } } goalPipeID = gEnv->pAISystem->AllocGoalPipeId(); if (pExtraData == 0) pExtraData = gEnv->pAISystem->CreateSignalExtraData(); pExtraData->iValue = goalPipeID; if (pPipeUser && bRegisterAsListener) { pPipeUser->RegisterGoalPipeListener( this, goalPipeID, "CDialogActorContext::ExecuteAI"); } IAIActor* pAIActor = CastToIAIActorSafe(pAI); if(pAIActor) pAIActor->SetSignal( 10, signalText, pEntity, pExtraData ); // 10 means this signal must be sent (but sent[!], not set) // even if the same signal is already present in the queue return true; }
virtual void OnExplosion(const ExplosionInfo &explosionInfo) { if(GetPortBool(&m_actInfo, EIP_Enable) == false) return; EntityId shooter = GetPortEntityId(&m_actInfo, EIP_ShooterId); if(shooter != 0 && shooter != explosionInfo.shooterId) return; EntityId impactTarget = GetPortEntityId(&m_actInfo, EIP_ImpactTargetId); if(impactTarget != 0 && explosionInfo.impact && impactTarget != explosionInfo.impact_targetId) return; IEntitySystem *pEntitySys = gEnv->pEntitySystem; IEntity *pTempEntity = pEntitySys->GetEntity(explosionInfo.weaponId); // check ammo match const string &ammo = GetPortString(&m_actInfo, EIP_Ammo); if(ammo.empty() == false) { if(pTempEntity == 0 || ammo.compare(pTempEntity->GetClass()->GetName()) != 0) return; } string ammoClass = pTempEntity ? pTempEntity->GetClass()->GetName() : ""; ActivateOutput(&m_actInfo, EOP_ShooterId, explosionInfo.shooterId); ActivateOutput(&m_actInfo, EOP_Ammo, ammoClass); ActivateOutput(&m_actInfo, EOP_Pos, explosionInfo.pos); ActivateOutput(&m_actInfo, EOP_Dir, explosionInfo.dir); ActivateOutput(&m_actInfo, EOP_Radius, explosionInfo.radius); ActivateOutput(&m_actInfo, EOP_Damage, explosionInfo.damage); ActivateOutput(&m_actInfo, EOP_Pressure, explosionInfo.pressure); ActivateOutput(&m_actInfo, EOP_HoleSize, explosionInfo.hole_size); const char *hitType = 0; if(CGameRules *pGR = g_pGame->GetGameRules()) hitType = pGR->GetHitType(explosionInfo.type); hitType = hitType ? hitType : ""; ActivateOutput(&m_actInfo, EOP_Type, string(hitType)); if(explosionInfo.impact) { ActivateOutput(&m_actInfo, EOP_ImpactTargetId, explosionInfo.impact_targetId); ActivateOutput(&m_actInfo, EOP_ImpactNormal, explosionInfo.impact_normal); ActivateOutput(&m_actInfo, EOP_ImpactVelocity, explosionInfo.impact_velocity); } }
void CVTOLVehicleManager::Reset() { //Drop all the registered Ids IEntitySystem *pEntitySystem = gEnv->pEntitySystem; for (TVTOLList::const_iterator it = m_vtolList.begin(), end = m_vtolList.end(); it != end; ++ it) { const EntityId vtolId = it->second.entityId; pEntitySystem->RemoveEntityEventListener(vtolId, ENTITY_EVENT_RESET, this); pEntitySystem->RemoveEntityEventListener(vtolId, ENTITY_EVENT_DONE, this); pEntitySystem->RemoveEntityEventListener(vtolId, ENTITY_EVENT_HIDE, this); pEntitySystem->RemoveEntityEventListener(vtolId, ENTITY_EVENT_UNHIDE, this); } m_vtolList.clear(); }
//------------------------------------------------------------------------ IItem* CInventory::GetItemByName(const char* name) const { if (!name) return 0; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; TInventoryCIt end = m_stats.slots.end(); for (TInventoryCIt it = m_stats.slots.begin(); it != end; ++it) { if (IEntity *pEntity = pEntitySystem->GetEntity(*it)) if (!strcmp(pEntity->GetName(),name)) return gEnv->pGame->GetIGameFramework()->GetIItemSystem()->GetItem(pEntity->GetId()); } return 0; }
//------------------------------------------------------------------------ void CVehicleActionEntityAttachment::Reset() { if(m_entityId) { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); pEntitySystem->RemoveEntity(m_entityId); } SpawnEntity(); if(m_timer > 0.0f) m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate); m_timer = 0.0f; }
//------------------------------------------------------------------------ EntityId CInventory::GetItemByClass(IEntityClass* pClass, IItem *pIgnoreItem) const { if (!pClass) return 0; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; TInventoryCIt end = m_stats.slots.end(); for (TInventoryCIt it = m_stats.slots.begin(); it != end; ++it) { if (IEntity *pEntity = pEntitySystem->GetEntity(*it)) if (pEntity->GetClass() == pClass) if(!pIgnoreItem || pIgnoreItem->GetEntity() != pEntity) return *it; } return 0; }
//------------------------------------------------------------------------ void CVehicleActionEntityAttachment::Update(const float deltaTime) { if(m_isAttached) return; IEntitySystem *pEntitySystem = gEnv->pEntitySystem; assert(pEntitySystem); IEntity *pEntity = pEntitySystem->GetEntity(m_entityId); if(!pEntity) return; IPhysicalEntity *pPhysEntity = pEntity->GetPhysics(); if(!pPhysEntity) return; pe_simulation_params paramsSim; float gravity; if(pPhysEntity->GetParams(¶msSim)) gravity = abs(paramsSim.gravity.z); else gravity = 9.82f; pe_status_dynamics dyn; if(pPhysEntity->GetStatus(&dyn)) { pe_action_impulse impulse; impulse.impulse = Matrix33(pEntity->GetWorldTM()) * Vec3(0.0f, 0.0f, 1.0f) * g_parachuteForce * gravity; impulse.impulse = impulse.impulse - dyn.v; impulse.impulse *= dyn.mass * deltaTime; impulse.iSource = 3; pPhysEntity->Action(&impulse); } m_timer -= deltaTime; if(m_timer <= 0.0f || dyn.v.z >= 0.0f) m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate); }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: m_errorLogSent = false; break; case eFE_Activate: if (IsPortActive(pActInfo, 0)) { IEntitySystem* pESys = gEnv->pEntitySystem; EntityId id1 = GetPortEntityId(pActInfo, 1); EntityId id2 = GetPortEntityId(pActInfo, 2); IEntity* pEnt1 = pESys->GetEntity( id1 ); IEntity* pEnt2 = pESys->GetEntity( id2 ); IEntity* pGraphEntity = pESys->GetEntity( pActInfo->pGraph->GetGraphEntity( 0 ) ); if (pEnt1==NULL || pEnt2==NULL) { if (!m_errorLogSent) { GameWarning("[flow] Entity::EntitiesInRange - flowgraph entity: %d:'%s' - at least one of the input entities is invalid!. Entity1: %d:'%s' Entity2: %d:'%s'", pActInfo->pGraph->GetGraphEntity( 0 ), pGraphEntity ? pGraphEntity->GetName() : "<NULL>", id1, pEnt1 ? pEnt1->GetName() : "<NULL>", id2, pEnt2 ? pEnt2->GetName() : "<NULL>" ); m_errorLogSent = true; } } else { const float range = GetPortFloat(pActInfo, 3); const float distance = pEnt1->GetWorldPos().GetDistance(pEnt2->GetWorldPos()) ; const bool inRange = (distance <= range); ActivateOutput(pActInfo, 0, inRange); ActivateOutput(pActInfo, 1 + (inRange ? 1 : 0), true); ActivateOutput(pActInfo, 3, distance); const Vec3 distVector = pEnt2->GetPos() - pEnt1->GetPos(); ActivateOutput(pActInfo, 4, distVector); m_errorLogSent = false; } } break; } }
/// Utility function for getting the entity at the index /// outEntity contains the entity if one could be found at the given index, otherwise NULL /// bPrepareFromPool is used to specify if the entity at the given index should be prepared from the pool if needed /// NOTE: Index -1 is special case for camera entity. /// Returns: True if there was an entityId specified at this index. Note you can still have a NULL outEntity even if true, indicating error. bool CFlowNode_FeatureTest::GetEntityAtIndex(int index, IEntity *&outEntity, bool bPrepareFromPool) { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; CRY_ASSERT(pEntitySystem); //IEntityPoolManager *pEntityPoolManager = pEntitySystem->GetIEntityPoolManager(); //CRY_ASSERT(pEntityPoolManager); outEntity = NULL; bool bHasEntry = false; if(index >= -1 && index < SEQ_ENTITY_COUNT) { EntityId id = GetPortEntityId(&m_actInfo, int(SEQ_ENTITY_FIRST_INPUT_PORT + index)); if(id) { bHasEntry = true; outEntity = pEntitySystem->GetEntity(id); // Prepare entity from pool if needed /*if (!outEntity && bPrepareFromPool && pEntityPoolManager->IsEntityBookmarked(id)) { if (pEntityPoolManager->PrepareFromPool(id, true)) { outEntity = pEntitySystem->GetEntity(id); } if (!outEntity) { CryLogAlways("Error: Test \"%s\" failed to prepare entity with id \'%u\' from the pool", Name(), id); } }*/ } } return bHasEntry; }
bool CGameRules::OnClientConnect(int channelId, bool isReset) { const float fTerrainSize = static_cast<float>(gEnv->p3DEngine->GetTerrainSize()); const float fTerrainElevation = gEnv->p3DEngine->GetTerrainElevation(fTerrainSize * 0.5f, fTerrainSize * 0.5f); const Vec3 vSpawnLocation(fTerrainSize * 0.5f, fTerrainSize * 0.5f, fTerrainElevation + 15.0f); IEntitySystem* pEntitySystem = gEnv->pEntitySystem; IEntityClass* pPlayerClass = pEntitySystem->GetClassRegistry()->FindClass("Player"); if (!pPlayerClass) return false; SEntitySpawnParams params; params.sName = "Player"; params.vPosition = vSpawnLocation; params.pClass = pPlayerClass; if (channelId) { params.nFlags |= ENTITY_FLAG_NEVER_NETWORK_STATIC; if (INetChannel* pNetChannel = gEnv->pGame->GetIGameFramework()->GetNetChannel(channelId)) { if (pNetChannel->IsLocal()) { params.id = LOCAL_PLAYER_ENTITY_ID; } } } IEntity* pPlayerEntity = pEntitySystem->SpawnEntity(params, false); CGameObject* pGameObject = static_cast<CGameObject*>(pPlayerEntity->GetProxy(ENTITY_PROXY_USER)); // always set the channel id before initializing the entity pGameObject->SetChannelId(channelId); return pEntitySystem->InitEntity(pPlayerEntity, params); }
void CPlayerPlugin_InteractiveEntityMonitor::Update( const float dt ) { m_timeUntilRefresh -= dt; #ifndef _RELEASE //Verify entity integrity InteractiveEntityDebugMap::iterator mapIter = m_debugMap.begin(); InteractiveEntityDebugMap::iterator mapEnd = m_debugMap.end(); while(mapIter != mapEnd) { if(!gEnv->pEntitySystem->GetEntity(mapIter->first)) { CryLog("[ERROR] InteractiveEntityMonitor. About to crash. Registered entity no longer exists: '%s'. Tell Gary (Really this time).", mapIter->second.c_str()); DesignerWarning(false, "[ERROR] InteractiveEntityMonitor. About to crash. Registered entity no longer exists: '%s'. Tell Gary (Really this time).", mapIter->second.c_str()); } ++mapIter; } #endif //_RELEASE IEntitySystem* pEntitySys = gEnv->pEntitySystem; const Vec3& playerPos = GetOwnerPlayer()->GetEntity()->GetWorldTM().GetColumn3(); if(m_bEnabled && (m_timeUntilRefresh < 0.f || playerPos.GetSquaredDistance2D(m_playerPrevPos) > g_pGameCVars->g_highlightingMovementDistanceToUpdateSquared)) { for(InteractiveEntityList::iterator it = m_interactiveEntityList.begin(); it!=m_interactiveEntityList.end(); ) { const EntityId entityId = it->first; IEntity* pEntity = pEntitySys->GetEntity(entityId); if(!pEntity) { it=m_interactiveEntityList.erase(it); continue; } if (IEntityRenderProxy* pRenderProxy = static_cast<IEntityRenderProxy *>(pEntity->GetProxy(ENTITY_PROXY_RENDER))) { const Vec3& entityPos = pEntity->GetWorldTM().GetColumn3(); const float distSq = entityPos.GetSquaredDistance2D(playerPos); const bool withinHighlightDistance = distSq <= g_pGameCVars->g_highlightingMaxDistanceToHighlightSquared; if( withinHighlightDistance ) { // Apply intensity fade over outer half distance float alpha = distSq * 2.0f - g_pGameCVars->g_highlightingMaxDistanceToHighlightSquared; alpha *= __fres(g_pGameCVars->g_highlightingMaxDistanceToHighlightSquared); alpha = 1.0f - clamp(alpha, 0.0f, 1.0f); if( (it->second & EIES_ShootToInteract) == 0 ) { pRenderProxy->SetHUDSilhouettesParams(m_silhouetteInteractColor.r*alpha, m_silhouetteInteractColor.g*alpha, m_silhouetteInteractColor.b*alpha, m_silhouetteInteractColor.a*alpha); } else { pRenderProxy->SetHUDSilhouettesParams(m_silhouetteShootColor.r*alpha, m_silhouetteShootColor.g*alpha, m_silhouetteShootColor.b*alpha, m_silhouetteShootColor.a*alpha); } it->second |= EIES_Highlighted; } else if( it->second & EIES_Highlighted ) { pRenderProxy->SetHUDSilhouettesParams(0.f, 0.f, 0.f, 0.f); it->second &= ~EIES_Highlighted; } } ++it; } m_playerPrevPos = playerPos; m_timeUntilRefresh = g_pGameCVars->g_highlightingTimeBetweenForcedRefresh; } }
Dumper(EntityId entityId, const char *desc) { IEntitySystem *pEntitySystem = gEnv->pEntitySystem; IEntity *pEntity = pEntitySystem->GetEntity(entityId); CryLogAlways(">> Id: %d [%s] $3%s $5%s", entityId, pEntity?pEntity->GetName():"<unknown>", pEntity?pEntity->GetClass()->GetName():"<unknown>", desc?desc:""); }
void CBattleDust::RecordEvent(EBattleDustEventType event, Vec3 worldPos, const IEntityClass* pClass) { FUNCTION_PROFILER(GetISystem(), PROFILE_GAME); if(!g_pGameCVars->g_battleDust_enable) return; if(!gEnv->bServer) return; // this typically means the xml file failed to load. Turn off the dust. if(m_maxParticleCount == 0) return; SBattleEventParameter param; if(!GetEventParams(event, pClass, param)) return; if(param.m_power == 0 || worldPos.IsEquivalent(Vec3(0,0,0))) return; if(m_pBattleEventClass == NULL) m_pBattleEventClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass( "BattleEvent" ); // first check if we need a new event bool newEvent = true; for(std::list<EntityId>::iterator it = m_eventIdList.begin(); it != m_eventIdList.end(); ++it) { EntityId areaId = (*it); CBattleEvent *pBattleArea = FindEvent(areaId); if(pBattleArea && CheckIntersection(pBattleArea, worldPos, param.m_power)) { // don't need a new event as this one is within an existing one. Just merge them. MergeAreas(pBattleArea, worldPos, param.m_power); pBattleArea->m_lifeRemaining += param.m_lifetime; pBattleArea->m_lifetime = pBattleArea->m_lifeRemaining; pBattleArea->m_lifetime = CLAMP(pBattleArea->m_lifetime, 0.0f, m_maxLifetime); pBattleArea->m_lifeRemaining = CLAMP(pBattleArea->m_lifeRemaining, 0.0f, m_maxLifetime); newEvent = false; break; } } if(newEvent) { IEntitySystem * pEntitySystem = gEnv->pEntitySystem; SEntitySpawnParams esp; esp.id = 0; esp.nFlags = 0; esp.pClass = m_pBattleEventClass; if (!esp.pClass) return; esp.pUserData = NULL; esp.sName = "BattleDust"; esp.vPosition = worldPos; // when CBattleEvent is created it will add itself to the list IEntity * pEntity = pEntitySystem->SpawnEntity( esp ); if(pEntity) { // find the just-added entity in the list, and set it's properties IGameObject* pGO = g_pGame->GetIGameFramework()->GetGameObject(pEntity->GetId()); if(pGO) { CBattleEvent* pNewEvent = static_cast<CBattleEvent*>(pGO->QueryExtension("BattleEvent")); if(pNewEvent) { pNewEvent->m_radius = param.m_power; pNewEvent->m_peakRadius = param.m_power; pNewEvent->m_lifetime = param.m_lifetime; pNewEvent->m_lifeRemaining = param.m_lifetime; pNewEvent->m_worldPos = worldPos; pNewEvent->m_lifetime = CLAMP(pNewEvent->m_lifetime, 0.0f, m_maxLifetime); pNewEvent->m_lifeRemaining = CLAMP(pNewEvent->m_lifeRemaining, 0.0f, m_maxLifetime); pGO->ChangedNetworkState(CBattleEvent::PROPERTIES_ASPECT); } } } } }