BVB Source Codes

CRYENGINE Show CentralInterestManager.cpp Source code

Return Download CRYENGINE: download CentralInterestManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "CentralInterestManager.h"
  5. #include "PersonalInterestManager.h"
  6. #include "Puppet.h"
  7.  
  8. // For persistent debugging
  9. #include <CryGame/IGameFramework.h>
  10.  
  11. const int CIM_RAYBUDGET = 1;                  // Max number of rays the interest system may fire per update; 2 would be extravagant
  12. const float CIM_UPDATE_TIME = .1f;
  13. const uint32 CIM_MAX_PIMS_PER_UPDATE = 2;
  14. const float CIM_MIN_DIST_SQ = 40.f * 40.f;
  15. const uint32 CIM_INITIAL_INTERESTING = 128;
  16.  
  17. //------------------------------------------------------------------------------------------------------------------------
  18.  
  19. // Zero singleton pointer
  20. CCentralInterestManager* CCentralInterestManager::m_pCIMInstance = NULL;
  21.  
  22. //------------------------------------------------------------------------------------------------------------------------
  23.  
  24. CCentralInterestManager::CCentralInterestManager()
  25. {
  26.         m_bEnabled = false;
  27.         m_pPersistentDebug = NULL;
  28.         m_bEntityEventListenerInstalled = false;
  29. }
  30.  
  31. //------------------------------------------------------------------------------------------------------------------------
  32.  
  33. void CCentralInterestManager::Init()
  34. {
  35.         m_cvDebugInterest = gEnv->pConsole->GetCVar("ai_DebugInterestSystem");
  36.         m_cvCastRays = gEnv->pConsole->GetCVar("ai_InterestSystemCastRays");
  37.  
  38.         // Init vectors to stored sizes
  39.         m_InterestingEntities.reserve(CIM_INITIAL_INTERESTING);
  40.  
  41.         m_lastUpdated = 0;
  42.         m_fUpdateTime = 0.f;
  43. }
  44.  
  45. //------------------------------------------------------------------------------------------------------------------------
  46.  
  47. CCentralInterestManager::~CCentralInterestManager()
  48. {
  49.         // Stop listening to all entities
  50.         if (m_bEntityEventListenerInstalled)
  51.         {
  52.                 gEnv->pEntitySystem->RemoveSink(this);
  53.                 m_bEntityEventListenerInstalled = false;
  54.         }
  55. }
  56.  
  57. //------------------------------------------------------------------------------------------------------------------------
  58.  
  59. CCentralInterestManager* CCentralInterestManager::GetInstance()
  60. {
  61.         // Return singleton pointer
  62.         // Create from scratch if need be
  63.         if (!m_pCIMInstance)
  64.         {
  65.                 m_pCIMInstance = new CCentralInterestManager;
  66.                 m_pCIMInstance->Init();
  67.         }
  68.  
  69.         return m_pCIMInstance;
  70. }
  71.  
  72. //------------------------------------------------------------------------------------------------------------------------
  73.  
  74. void CCentralInterestManager::Reset()
  75. {
  76.         // Clear tracking vectors
  77.         for (TVecInteresting::iterator itI = m_InterestingEntities.begin(); itI != m_InterestingEntities.end(); ++itI)
  78.                 itI->Invalidate();
  79.  
  80.         for (TVecPIMs::iterator itP = m_PIMs.begin(); itP != m_PIMs.end(); ++itP)
  81.                 itP->Assign(NILREF);
  82.  
  83.         m_lastUpdated = 0;
  84.         m_fUpdateTime = 0.f;
  85.  
  86.         stl::free_container(m_Listeners);
  87.  
  88.         bool bRegisterWithEntitySystem = true;
  89.         if (gEnv->bMultiplayer)
  90.         {
  91.                 if (ICVar* pEnableAI = gEnv->pConsole->GetCVar("sv_AISystem"))
  92.                 {
  93.                         if (!pEnableAI->GetIVal())
  94.                         {
  95.                                 bRegisterWithEntitySystem = false;
  96.                         }
  97.                 }
  98.         }
  99.  
  100.         if (m_bEntityEventListenerInstalled != bRegisterWithEntitySystem)
  101.         {
  102.                 if (bRegisterWithEntitySystem)
  103.                 {
  104.                         // Start listening to all moving entities
  105.                         CryLog("Registering CentralInterestManager with EntitySystem");
  106.                         gEnv->pEntitySystem->AddSink(this, IEntitySystem::OnSpawn | IEntitySystem::OnRemove, 0);
  107.                         m_bEntityEventListenerInstalled = true;
  108.                 }
  109.                 else
  110.                 {
  111.                         CryLog("Unregistering CentralInterestManager from EntitySystem");
  112.                         gEnv->pEntitySystem->RemoveSink(this);
  113.                         m_bEntityEventListenerInstalled = false;
  114.                 }
  115.         }
  116. }
  117.  
  118. //------------------------------------------------------------------------------------------------------------------------
  119.  
  120. bool CCentralInterestManager::Enable(bool bEnable)
  121. {
  122.         if (m_bEnabled != bEnable)
  123.         {
  124.                 m_bEnabled = bEnable;
  125.  
  126.                 if (m_bEnabled)
  127.                 {
  128.                         if (!m_pPersistentDebug)
  129.                         {
  130.                                 if (gEnv->pGameFramework)
  131.                                 {
  132.                                         m_pPersistentDebug = gEnv->pGameFramework->GetIPersistantDebug();
  133.                                 }
  134.                         }
  135.                 }
  136.         }
  137.  
  138.         return m_bEnabled;
  139. }
  140.  
  141. //------------------------------------------------------------------------------------------------------------------------
  142.  
  143. void CCentralInterestManager::Update(float fDelta)
  144. {
  145.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  146.  
  147.         if (!m_bEnabled)
  148.                 return;
  149.  
  150.         m_fUpdateTime -= fDelta;
  151.         if (m_fUpdateTime > 0.f)
  152.                 return;
  153.  
  154.         m_fUpdateTime = CIM_UPDATE_TIME;
  155.  
  156.         // Cache camera position
  157.         const Vec3 vCameraPos = gEnv->pSystem->GetViewCamera().GetPosition();
  158.  
  159.         // Update all the active PIMs
  160.         const uint32 PIMCount = m_PIMs.size();
  161.         const uint32 MaxUpdateCount = std::min<uint32>(PIMCount, CIM_MAX_PIMS_PER_UPDATE);
  162.  
  163.         uint32 loopCount = 0;
  164.         for (uint32 uCount = 0; (uCount < MaxUpdateCount) && (loopCount < PIMCount); ++loopCount)
  165.         {
  166.                 m_lastUpdated = (m_lastUpdated + 1) % PIMCount;
  167.  
  168.                 CPersonalInterestManager& pim = m_PIMs[m_lastUpdated];
  169.  
  170.                 if (!pim.IsReset())
  171.                 {
  172.                         // Sanity check to only update active non-combat AIs and AIs that have been updated by the AISystem at least once
  173.                         // (otherwise this blocks the AISystem update calls for the entity).
  174.                         CPuppet* const pPuppet = CastToCPuppetSafe(pim.GetAssigned());
  175.                         if (pPuppet)
  176.                         {
  177.                                 IAIActorProxy* pProxy = pPuppet->GetProxy();
  178.                                 if (pProxy &&
  179.                                     !pPuppet->IsAlarmed() &&
  180.                                     (pPuppet->GetAlertness() == 0) &&
  181.                                     pPuppet->IsActive() &&
  182.                                     pPuppet->IsUpdatedOnce() &&
  183.                                     !pProxy->IsDead() &&
  184.                                     !pProxy->GetLinkedVehicleEntityId() &&
  185.                                     !pProxy->IsPlayingSmartObjectAction())
  186.                                 {
  187.                                         bool bCloseToCamera = pPuppet->GetPos().GetSquaredDistance2D(vCameraPos) < CIM_MIN_DIST_SQ;
  188.                                         if (pim.Update(bCloseToCamera))
  189.                                         {
  190.                                                 ++uCount;
  191.                                         }
  192.                                 }
  193.                                 else
  194.                                 {
  195.                                         if (pim.ForgetInterestingEntity())
  196.                                         {
  197.                                                 ++uCount;
  198.                                         }
  199.                                 }
  200.                         }
  201.                 }
  202.         }
  203. }
  204.  
  205. //------------------------------------------------------------------------------------------------------------------------
  206. void CCentralInterestManager::Serialize(TSerialize ser)
  207. {
  208.         ser.Value("m_InterestingEntities", m_InterestingEntities);
  209.         ser.Value("m_PIMs", m_PIMs);
  210. }
  211.  
  212. //------------------------------------------------------------------------------------------------------------------------
  213. bool CCentralInterestManager::GatherData(IEntity* pEntity, SEntityInterest& entityInterest)
  214. {
  215.         assert(pEntity);
  216.  
  217.         SEntityInterest tempEntityInterest;
  218.         bool bEnabled = false;
  219.  
  220.         if (IEntityArchetype* pEntityArchetype = pEntity->GetArchetype())
  221.         {
  222.                 if (IScriptTable* pProperties = pEntityArchetype->GetProperties())
  223.                 {
  224.                         bEnabled = ReadDataFromTable(pProperties, tempEntityInterest);
  225.                         entityInterest.Set(tempEntityInterest);
  226.                 }
  227.         }
  228.  
  229.         SmartScriptTable ssInstanceTable;
  230.         bool bFound = false;
  231.         if (IScriptTable* pScriptTable = pEntity->GetScriptTable())
  232.         {
  233.                 bFound = pScriptTable->GetValue("PropertiesInstance", ssInstanceTable);
  234.                 if (!bFound)
  235.                 {
  236.                         bFound = pScriptTable->GetValue("Properties", ssInstanceTable);
  237.                 }
  238.         }
  239.  
  240.         if (bFound)
  241.         {
  242.                 SmartScriptTable ssInterestInstanceTable;
  243.                 if (ssInstanceTable->GetValue("Interest", ssInterestInstanceTable))
  244.                 {
  245.                         bool bOverrideArchetype = true;
  246.                         bool bExists = ssInterestInstanceTable->GetValue("bOverrideArchetype", bOverrideArchetype);
  247.  
  248.                         if (!bExists || bOverrideArchetype)
  249.                         {
  250.                                 bEnabled = ReadDataFromTable(ssInstanceTable, tempEntityInterest);
  251.                                 entityInterest.Set(tempEntityInterest);
  252.                         }
  253.                 }
  254.         }
  255.  
  256.         return bEnabled;
  257. }
  258.  
  259. //------------------------------------------------------------------------------------------------------------------------
  260. bool CCentralInterestManager::GatherData(IEntity* pEntity, SActorInterestSettings& actorInterestSettings)
  261. {
  262.         assert(pEntity);
  263.  
  264.         SActorInterestSettings tempActorInterestSettings;
  265.  
  266.         if (IEntityArchetype* pEntityArchetype = pEntity->GetArchetype())
  267.         {
  268.                 if (IScriptTable* pProperties = pEntityArchetype->GetProperties())
  269.                 {
  270.                         ReadDataFromTable(pProperties, tempActorInterestSettings);
  271.                         actorInterestSettings = tempActorInterestSettings;
  272.                 }
  273.         }
  274.  
  275.         SmartScriptTable ssInstanceTable;
  276.         bool bFound = pEntity->GetScriptTable()->GetValue("PropertiesInstance", ssInstanceTable);
  277.         if (!bFound)
  278.         {
  279.                 bFound = pEntity->GetScriptTable()->GetValue("Properties", ssInstanceTable);
  280.         }
  281.  
  282.         if (bFound)
  283.         {
  284.                 SmartScriptTable ssInterestInstanceTable;
  285.                 if (ssInstanceTable->GetValue("Interest", ssInterestInstanceTable))
  286.                 {
  287.                         bool bOverrideArchetype = true;
  288.                         bool bExists = ssInterestInstanceTable->GetValue("bOverrideArchetype", bOverrideArchetype);
  289.  
  290.                         if (!bExists || bOverrideArchetype)
  291.                         {
  292.                                 ReadDataFromTable(ssInstanceTable, tempActorInterestSettings);
  293.                                 actorInterestSettings = tempActorInterestSettings;
  294.                         }
  295.                 }
  296.         }
  297.  
  298.         return actorInterestSettings.m_bEnablePIM;
  299. }
  300.  
  301. //------------------------------------------------------------------------------------------------------------------------
  302.  
  303. bool CCentralInterestManager::RegisterInterestingEntity(IEntity* pEntity, float fRadius, float fBaseInterest, const char* szActionName, const Vec3& vOffset, float fPause, int nbShared)
  304. {
  305.         SEntityInterest* pInterest = NULL;
  306.         bool bOnlyUpdate = false;
  307.         bool bSomethingChanged = false;
  308.  
  309.         TVecInteresting::iterator itI = m_InterestingEntities.begin();
  310.         TVecInteresting::iterator itEnd = m_InterestingEntities.end();
  311.         for (; itI != itEnd; ++itI)
  312.         {
  313.                 if (itI->m_entityId == pEntity->GetId())
  314.                 {
  315.                         pInterest = &(*itI);
  316.                         bSomethingChanged = itI->Set(pEntity->GetId(), fRadius, fBaseInterest, szActionName, vOffset, fPause, nbShared);
  317.                         break;
  318.                 }
  319.         }
  320.  
  321.         if (!pInterest)
  322.         {
  323.                 // Find a spare PIM
  324.                 itI = m_InterestingEntities.begin();
  325.                 for (; itI != itEnd; ++itI)
  326.                 {
  327.                         if (!(itI->IsValid()))
  328.                                 break;
  329.                 }
  330.  
  331.                 if (itI == itEnd)
  332.                 {
  333.                         m_InterestingEntities.push_back(SEntityInterest(pEntity->GetId(), fRadius, fBaseInterest, szActionName, vOffset, fPause, nbShared));
  334.                         pInterest = &(m_InterestingEntities.back());
  335.                 }
  336.                 else
  337.                 {
  338.                         itI->Set(pEntity->GetId(), fRadius, fBaseInterest, szActionName, vOffset, fPause, nbShared);
  339.                         pInterest = &(*itI);
  340.                 }
  341.  
  342.                 bSomethingChanged = true;
  343.         }
  344.  
  345.         if (IsDebuggingEnabled() && pInterest && bSomethingChanged)
  346.         {
  347.                 string sText;
  348.                 sText.Format("Interest: %0.1f Radius: %0.1f Action: %s Pause: %0.1f Shared: %s",
  349.                              pInterest->m_fInterest,
  350.                              pInterest->m_fRadius,
  351.                              pInterest->GetAction(),
  352.                              pInterest->m_fPause,
  353.                              (pInterest->m_nbShared > 0) ? "Yes" : "No");
  354.                 AddDebugTag(pInterest->m_entityId, sText.c_str());
  355.         }
  356.  
  357.         return bSomethingChanged;
  358. }
  359.  
  360. //------------------------------------------------------------------------------------------------------------------------
  361.  
  362. void CCentralInterestManager::ChangeInterestingEntityProperties(IEntity* pEntity, float fRadius, float fBaseInterest, const char* szActionName, const Vec3& vOffset, float fPause, int nbShared)
  363. {
  364.         assert(pEntity);
  365.  
  366.         SEntityInterest entityInterest;
  367.         GatherData(pEntity, entityInterest);
  368.         entityInterest.Set(pEntity->GetId(), fRadius, fBaseInterest, szActionName, vOffset, fPause, nbShared);
  369.         RegisterInterestingEntity(pEntity, entityInterest.m_fRadius, entityInterest.m_fInterest, entityInterest.m_sActionName, entityInterest.m_vOffset, entityInterest.m_fPause, entityInterest.m_nbShared);
  370. }
  371.  
  372. //------------------------------------------------------------------------------------------------------------------------
  373.  
  374. void CCentralInterestManager::ChangeInterestedAIActorProperties(IEntity* pEntity, float fInterestFilter, float fAngleCos)
  375. {
  376.         assert(pEntity);
  377.  
  378.         SActorInterestSettings actorInterestSettings;
  379.         GatherData(pEntity, actorInterestSettings);
  380.         actorInterestSettings.Set(actorInterestSettings.m_bEnablePIM, fInterestFilter, fAngleCos);
  381.         RegisterInterestedAIActor(pEntity, actorInterestSettings.m_bEnablePIM, actorInterestSettings.m_fInterestFilter, actorInterestSettings.m_fAngleCos);
  382. }
  383.  
  384. //------------------------------------------------------------------------------------------------------------------------
  385.  
  386. void CCentralInterestManager::DeregisterInterestingEntity(IEntity* pEntity)
  387. {
  388.         TVecInteresting::iterator itI = m_InterestingEntities.begin();
  389.         TVecInteresting::iterator itEnd = m_InterestingEntities.end();
  390.         for (; itI != itEnd; ++itI)
  391.         {
  392.                 if (itI->m_entityId == pEntity->GetId())
  393.                 {
  394.                         itI->Invalidate();
  395.                 }
  396.         }
  397. }
  398.  
  399. //------------------------------------------------------------------------------------------------------------------------
  400.  
  401. bool CCentralInterestManager::RegisterInterestedAIActor(IEntity* pEntity, bool bEnablePIM, float fInterestFilter, float fAngleCos)
  402. {
  403.         // Try to get an AI object
  404.         IAIObject* pAIObject = pEntity->GetAI();
  405.         if (!pAIObject)
  406.                 return false;
  407.  
  408.         // Try to cast to pAIActor
  409.         CAIActor* pAIActor = pAIObject->CastToCAIActor();
  410.         if (!pAIActor)
  411.                 return false;
  412.  
  413.         if (CPersonalInterestManager* pPIM = FindPIM(pEntity))
  414.         {
  415.                 pPIM->SetSettings(bEnablePIM, fInterestFilter, fAngleCos);
  416.                 return true;
  417.         }
  418.  
  419.         // Find a spare PIM
  420.         TVecPIMs::iterator it = m_PIMs.begin();
  421.         TVecPIMs::iterator itEnd = m_PIMs.end();
  422.         for (; it != itEnd; ++it)
  423.         {
  424.                 CPersonalInterestManager* p0 = &(*it);
  425.                 if (it->IsReset())
  426.                 {
  427.                         it->Assign(pAIActor);
  428.                         it->SetSettings(bEnablePIM, fInterestFilter, fAngleCos);
  429.                         break;
  430.                 }
  431.         }
  432.  
  433.         if (it == itEnd)
  434.         {
  435.                 // m_PIMs is freed on Reset, so this is the most convenient place to preallocate
  436.                 m_PIMs.push_back(CPersonalInterestManager(pAIActor));
  437.                 m_lastUpdated = 0;
  438.  
  439.                 if (CPersonalInterestManager* pPIM = FindPIM(pEntity))
  440.                 {
  441.                         pPIM->SetSettings(bEnablePIM, fInterestFilter, fAngleCos);
  442.                 }
  443.                 else
  444.                 {
  445.                         assert(false && "Cannot find a just recently created PersonalInterestManager!");
  446.                 }
  447.         }
  448.  
  449.         // Mark this to say we successfully registered it
  450.         return true;
  451. }
  452.  
  453. //------------------------------------------------------------------------------------------------------------------------
  454.  
  455. CPersonalInterestManager* CCentralInterestManager::FindPIM(IEntity* pEntity)
  456. {
  457.         assert(pEntity);
  458.         if (pEntity)
  459.         {
  460.                 EntityId entityId = pEntity->GetId();
  461.  
  462.                 TVecPIMs::iterator it = m_PIMs.begin();
  463.                 TVecPIMs::iterator itEnd = m_PIMs.end();
  464.  
  465.                 for (; it != itEnd; ++it)
  466.                 {
  467.                         CPersonalInterestManager& pim = *it;
  468.                         CAIActor* pAIActor = pim.GetAssigned();
  469.                         if ((pAIActor != NULL) && (pAIActor->GetEntityID() == entityId))
  470.                                 return &pim;
  471.                 }
  472.         }
  473.  
  474.         return NULL;
  475. }
  476.  
  477. //------------------------------------------------------------------------------------------------------------------------
  478.  
  479. bool CCentralInterestManager::DeregisterInterestedAIActor(IEntity* pEntity)
  480. {
  481.         // Try to get an AI object
  482.         IAIObject* pAIObject = pEntity->GetAI();
  483.         if (!pAIObject)
  484.                 return false;
  485.  
  486.         // Try to cast to actor
  487.         CAIActor* pAIActor = pAIObject->CastToCAIActor();
  488.         if (!pAIActor)
  489.                 return false;
  490.  
  491.         if (CPersonalInterestManager* pPIM = FindPIM(pEntity))
  492.         {
  493.                 pPIM->Assign(NILREF);
  494.         }
  495.  
  496.         return true;
  497. }
  498.  
  499. //------------------------------------------------------------------------------------------------------------------------
  500.  
  501. void CCentralInterestManager::AddDebugTag(EntityId entityId, const char* szString, float fTime)
  502. {
  503.         if (IsDebuggingEnabled())
  504.         {
  505.                 string text;
  506.                 text.Format("[%s]: %s", gEnv->pEntitySystem->GetEntity(entityId)->GetName(), szString);
  507.  
  508.                 if (!m_pPersistentDebug)
  509.                 {
  510.                         m_pPersistentDebug = gEnv->pGameFramework->GetIPersistantDebug();
  511.                 }
  512.  
  513.                 if (fTime < 0.f)
  514.                 {
  515.                         m_pPersistentDebug->AddEntityTag(SEntityTagParams(entityId, text.c_str()));
  516.                 }
  517.                 else
  518.                 {
  519.                         m_pPersistentDebug->AddEntityTag(SEntityTagParams(entityId, text.c_str(), 1.5f, ColorF(1.f, 1.f, 1.f, 1.f), fTime));
  520.                 }
  521.         }
  522. }
  523.  
  524. //------------------------------------------------------------------------------------------------------------------------
  525.  
  526. void CCentralInterestManager::DeregisterObject(IEntity* pEntity)
  527. {
  528.         assert(pEntity);
  529.         if (CastToIAIActorSafe(pEntity->GetAI()))
  530.         {
  531.                 DeregisterInterestedAIActor(pEntity);
  532.         }
  533.  
  534.         // Find this entity
  535.         EntityId entityId = pEntity->GetId();
  536.         TVecInteresting::iterator it = m_InterestingEntities.begin();
  537.         TVecInteresting::iterator itEnd = m_InterestingEntities.end();
  538.         for (; it != itEnd; ++it)
  539.         {
  540.                 if (it->m_entityId == entityId)
  541.                         break;
  542.         }
  543.  
  544.         if (it != itEnd)
  545.         {
  546.                 it->Invalidate();
  547.  
  548.                 // Debugging
  549.                 AddDebugTag(entityId, "Deregistered");
  550.         }
  551. }
  552.  
  553. //------------------------------------------------------------------------------------------------------------------------
  554. void CCentralInterestManager::OnEntityEvent(IEntity* pEntity, SEntityEvent& event)
  555. {
  556.         assert(pEntity);
  557.  
  558.         if ((event.event == ENTITY_EVENT_START_LEVEL) ||
  559.             (event.event == ENTITY_EVENT_RESET && event.nParam[0] == 1) ||
  560.             (event.event == ENTITY_EVENT_UNHIDE))
  561.         {
  562.                 RegisterObject(pEntity);
  563.         }
  564.         else
  565.         {
  566.                 DeregisterObject(pEntity);
  567.  
  568.                 // Is this a potential pAIActor?
  569.                 if (CastToIAIActorSafe(pEntity->GetAI()))
  570.                 {
  571.                         DeregisterInterestedAIActor(pEntity);
  572.                 }
  573.         }
  574. }
  575.  
  576. //------------------------------------------------------------------------------------------------------------------------
  577. void CCentralInterestManager::RegisterObject(IEntity* pEntity)
  578. {
  579.         assert(pEntity);
  580.  
  581.         if (CastToIAIActorSafe(pEntity->GetAI()))
  582.         {
  583.                 SActorInterestSettings actorInterestSettings;
  584.                 if (GatherData(pEntity, actorInterestSettings))
  585.                 {
  586.                         RegisterInterestedAIActor(pEntity, actorInterestSettings.m_bEnablePIM, actorInterestSettings.m_fInterestFilter, actorInterestSettings.m_fAngleCos);
  587.                 }
  588.         }
  589.         else
  590.         {
  591.                 SEntityInterest entityInterest;
  592.                 if (GatherData(pEntity, entityInterest))
  593.                 {
  594.                         RegisterInterestingEntity(pEntity,
  595.                                                   entityInterest.m_fRadius,
  596.                                                   entityInterest.m_fInterest,
  597.                                                   entityInterest.m_sActionName,
  598.                                                   entityInterest.m_vOffset,
  599.                                                   entityInterest.m_fPause,
  600.                                                   entityInterest.m_nbShared);
  601.                 }
  602.         }
  603. }
  604.  
  605. //------------------------------------------------------------------------------------------------------------------------
  606. bool CCentralInterestManager::ReadDataFromTable(const SmartScriptTable& ssTable, SEntityInterest& entityInterest)
  607. {
  608.         const char* szAction = NULL;
  609.         bool bInteresting = false;
  610.  
  611.         SmartScriptTable ssInterestTable;
  612.         if (ssTable->GetValue("Interest", ssInterestTable))
  613.         {
  614.                 ssInterestTable->GetValue("bInteresting", bInteresting);
  615.  
  616.                 ssInterestTable->GetValue("soaction_Action", szAction);
  617.                 if (szAction)
  618.                 {
  619.                         entityInterest.SetAction(szAction);
  620.                 }
  621.  
  622.                 ssInterestTable->GetValue("InterestLevel", entityInterest.m_fInterest);
  623.                 ssInterestTable->GetValue("Radius", entityInterest.m_fRadius);
  624.                 ssInterestTable->GetValue("vOffset", entityInterest.m_vOffset);
  625.                 ssInterestTable->GetValue("Pause", entityInterest.m_fPause);
  626.  
  627.                 bool bShared = false;
  628.                 ssInterestTable->GetValue("bShared", bShared);
  629.                 entityInterest.m_nbShared = bShared ? 1 : 0;
  630.         }
  631.  
  632.         return bInteresting;
  633. }
  634.  
  635. //------------------------------------------------------------------------------------------------------------------------
  636. bool CCentralInterestManager::ReadDataFromTable(const SmartScriptTable& ssTable, SActorInterestSettings& actorInterestSettings)
  637. {
  638.         SmartScriptTable ssInterestTable;
  639.  
  640.         if (ssTable->GetValue("Interest", ssInterestTable))
  641.         {
  642.                 ssInterestTable->GetValue("bInterested", actorInterestSettings.m_bEnablePIM);
  643.                 ssInterestTable->GetValue("MinInterestLevel", actorInterestSettings.m_fInterestFilter);
  644.                 float fAngleInDegrees;
  645.                 ssInterestTable->GetValue("Angle", fAngleInDegrees);
  646.                 actorInterestSettings.SetAngleInDegrees(fAngleInDegrees);
  647.         }
  648.  
  649.         return actorInterestSettings.m_bEnablePIM;
  650. }
  651.  
  652. //------------------------------------------------------------------------------------------------------------------------
  653. void CCentralInterestManager::OnSpawn(IEntity* pEntity, SEntitySpawnParams&)
  654. {
  655.         assert(pEntity);
  656.  
  657.         if (IScriptTable* pEntityScriptTable = pEntity->GetScriptTable())
  658.         {
  659.                 SmartScriptTable ssInstanceTable;
  660.                 bool bFound = pEntityScriptTable->GetValue("PropertiesInstance", ssInstanceTable);
  661.                 if (!bFound)
  662.                 {
  663.                         bFound = pEntityScriptTable->GetValue("Properties", ssInstanceTable);
  664.                 }
  665.  
  666.                 if (bFound)
  667.                 {
  668.                         SmartScriptTable ssInterestInstanceTable;
  669.                         if (ssInstanceTable->GetValue("Interest", ssInterestInstanceTable))
  670.                         {
  671.                                 IEntitySystem* pEntitySystem = gEnv->pEntitySystem;
  672.                                 EntityId entityId = pEntity->GetId();
  673.  
  674.                                 pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_START_LEVEL, this);
  675.                                 pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_DONE, this);
  676.                                 pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_RESET, this);
  677.                                 pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_HIDE, this);
  678.                                 pEntitySystem->AddEntityEventListener(entityId, ENTITY_EVENT_UNHIDE, this);
  679.                         }
  680.                 }
  681.         }
  682. }
  683.  
  684. //------------------------------------------------------------------------------------------------------------------------
  685.  
  686. bool CCentralInterestManager::OnRemove(IEntity* pEntity)
  687. {
  688.         assert(pEntity);
  689.  
  690.         DeregisterObject(pEntity);
  691.  
  692.         // Is this a potential AI Actor?
  693.         if (IAIObject* pAIObject = pEntity->GetAI())
  694.         {
  695.                 if (pAIObject->CastToIAIActor())
  696.                 {
  697.                         DeregisterInterestedAIActor(pEntity);
  698.                 }
  699.         }
  700.  
  701.         return true;
  702. }
  703.  
  704. //------------------------------------------------------------------------------------------------------------------------
  705.  
  706. void CCentralInterestManager::RegisterListener(IInterestListener* pInterestListener, EntityId idInterestingEntity)
  707. {
  708.         assert(pInterestListener);
  709.         assert(idInterestingEntity);
  710.  
  711.         if (m_Listeners.find(idInterestingEntity) == m_Listeners.end())
  712.         {
  713.                 m_Listeners.insert(TMapListeners::value_type(idInterestingEntity, pInterestListener));
  714.         }
  715. }
  716.  
  717. //------------------------------------------------------------------------------------------------------------------------
  718.  
  719. void CCentralInterestManager::UnRegisterListener(IInterestListener* pInterestListener, EntityId idInterestingEntity)
  720. {
  721.         assert(pInterestListener);
  722.         assert(idInterestingEntity);
  723.  
  724.         TMapListeners::iterator it = m_Listeners.find(idInterestingEntity);
  725.  
  726.         while (it != m_Listeners.end())
  727.         {
  728.                 m_Listeners.erase(it);
  729.                 it = m_Listeners.find(idInterestingEntity);
  730.         }
  731. }
  732.  
  733. //------------------------------------------------------------------------------------------------------------------------
  734.  
  735. void CCentralInterestManager::OnInterestEvent(IInterestListener::EInterestEvent eInterestEvent, EntityId idActor, EntityId idInterestingEntity)
  736. {
  737.         assert(idActor);
  738.         assert(idInterestingEntity);
  739.  
  740.         std::pair<TMapListeners::iterator, TMapListeners::iterator> range;
  741.         range = m_Listeners.equal_range(idInterestingEntity);
  742.  
  743.         TMapListeners::iterator itEnd = m_Listeners.end();
  744.         TMapListeners::iterator it = range.first;
  745.         for (; (it != itEnd) && (it != range.second); ++it)
  746.         {
  747.                 it->second->OnInterestEvent(eInterestEvent, idActor, idInterestingEntity);
  748.         }
  749. }
  750.  
  751. //-----------------------------------------------------------------------------------------------------
  752.  
  753. bool SEntityInterest::Set(EntityId entityId, float fRadius, float fInterest, const char* szActionName, const Vec3& vOffset, float fPause, int nbShared)
  754. {
  755.         bool bChanged = false;
  756.  
  757.         if (entityId != m_entityId)
  758.         {
  759.                 m_entityId = entityId;
  760.                 bChanged = true;
  761.         }
  762.  
  763.         if (fRadius >= 0.f && (fRadius != m_fRadius))
  764.         {
  765.                 m_fRadius = fRadius;
  766.                 bChanged = true;
  767.         }
  768.  
  769.         if (fInterest >= 0.f && (fInterest != m_fInterest))
  770.         {
  771.                 m_fInterest = fInterest;
  772.                 bChanged = true;
  773.         }
  774.  
  775.         if (!vOffset.IsZero() && (vOffset != m_vOffset))
  776.         {
  777.                 m_vOffset = vOffset;
  778.                 bChanged = true;
  779.         }
  780.  
  781.         if (szActionName && (strlen(szActionName) > 0) && m_sActionName.compare(szActionName))
  782.         {
  783.                 SetAction(szActionName);
  784.                 bChanged = true;
  785.         }
  786.  
  787.         if (fPause >= 0.f && (fPause != m_fPause))
  788.         {
  789.                 m_fPause = fPause;
  790.                 bChanged = true;
  791.         }
  792.  
  793.         if (nbShared >= 0 && (nbShared != m_nbShared))
  794.         {
  795.                 m_nbShared = nbShared;
  796.                 bChanged = true;
  797.         }
  798.  
  799.         if (bChanged && (entityId > 0) && gAIEnv.pSmartObjectManager)
  800.         {
  801.                 gAIEnv.pSmartObjectManager->AddSmartObjectState(GetEntity(), "Registered");
  802.         }
  803.  
  804.         return bChanged;
  805. }
  806.  
  807. void SEntityInterest::SetAction(const char* szActionName)
  808. {
  809.         m_sActionName = szActionName;
  810.  
  811.         m_eSupportedActorClasses = 0;
  812.  
  813.         if (m_sActionName.find("_human_") != string::npos)
  814.         {
  815.                 m_eSupportedActorClasses |= eACTOR_CLASS_HUMAN_GRUNT;
  816.         }
  817.         if (m_sActionName.find("_grunt_") != string::npos)
  818.         {
  819.                 m_eSupportedActorClasses |= eACTOR_CLASS_ALIEN_GRUNT;
  820.         }
  821.         if (m_sActionName.find("_stalker_") != string::npos)
  822.         {
  823.                 m_eSupportedActorClasses |= eACTOR_CLASS_ALIEN_STALKER;
  824.         }
  825.  
  826.         if (m_eSupportedActorClasses == 0)
  827.         {
  828.                 m_eSupportedActorClasses |= eACTOR_CLASS_HUMAN_GRUNT;
  829.                 m_eSupportedActorClasses |= eACTOR_CLASS_ALIEN_GRUNT;
  830.                 m_eSupportedActorClasses |= eACTOR_CLASS_ALIEN_STALKER;
  831.         }
  832. }
  833.  
  834. bool SEntityInterest::SupportsActorClass(const char* szActorClass) const
  835. {
  836.         if (!strcmp(szActorClass, "HumanGrunt"))
  837.                 return (m_eSupportedActorClasses & eACTOR_CLASS_HUMAN_GRUNT) != 0;
  838.         else if (!strcmp(szActorClass, "AlienGrunt"))
  839.                 return (m_eSupportedActorClasses & eACTOR_CLASS_ALIEN_GRUNT) != 0;
  840.         else if (!strcmp(szActorClass, "AlienStalker"))
  841.                 return (m_eSupportedActorClasses & eACTOR_CLASS_ALIEN_STALKER) != 0;
  842.  
  843.         return false;
  844. }
  845.  
downloadCentralInterestManager.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top