BVB Source Codes

CRYENGINE Show PersonalRangeSignaling.cpp Source code

Return Download CRYENGINE: download PersonalRangeSignaling.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    ---------------------------------------------------------------------
  5.    File name:   Range.h
  6.    $Id$
  7.    $DateTime$
  8.    Description: Manager per-actor signals to other actors by range
  9.    ---------------------------------------------------------------------
  10.    History:
  11.    - 09:04:2007 : Created by Ricardo Pillosu
  12.  
  13.  *********************************************************************/
  14. #include "StdAfx.h"
  15. #include "PersonalRangeSignaling.h"
  16. #include "RangeSignaling.h"
  17. #include "Range.h"
  18. #include "AngleAlert.h"
  19. #include "IUIDraw.h"
  20.  
  21. #include <functional>
  22. #include <CryAISystem/IAIObject.h>
  23.  
  24. // Description:
  25. //   Constructor
  26. // Arguments:
  27. //
  28. // Return:
  29. //
  30. CPersonalRangeSignaling::CPersonalRangeSignaling(CRangeSignaling* pParent) : m_bInit(false), m_bEnabled(false), m_pParent(pParent), m_EntityId(0)
  31. {
  32.         CRY_ASSERT(pParent != NULL);
  33.  
  34.         m_pDefaultFont = gEnv->pCryFont->GetFont("default");
  35.         CRY_ASSERT(m_pDefaultFont);
  36. }
  37.  
  38. // Description:
  39. //   Destructor
  40. // Arguments:
  41. //
  42. // Return:
  43. //
  44. CPersonalRangeSignaling::~CPersonalRangeSignaling()
  45. {
  46.         Reset();
  47.  
  48.         for (int i = 0; i < m_vecRanges.size(); ++i)
  49.         {
  50.                 SAFE_DELETE(m_vecRanges[i]);
  51.         }
  52.  
  53.         m_vecRanges.clear();
  54.  
  55.         MapTargetRanges::iterator itTargetRange = m_mapTargetRanges.begin();
  56.         MapTargetRanges::iterator itTargetRangeEnd = m_mapTargetRanges.end();
  57.         for (; itTargetRange != itTargetRangeEnd; ++itTargetRange)
  58.         {
  59.                 for (int i = 0; i < itTargetRange->second.size(); ++i)
  60.                 {
  61.                         SAFE_DELETE(itTargetRange->second[i]);
  62.                 }
  63.         }
  64.  
  65.         m_mapTargetRanges.clear();
  66.  
  67.         for (int i = 0; i < m_vecAngles.size(); ++i)
  68.         {
  69.                 SAFE_DELETE(m_vecAngles[i]);
  70.         }
  71.  
  72.         m_vecAngles.clear();
  73.  
  74.         SetListener(false);
  75. }
  76.  
  77. // Description:
  78. //
  79. // Arguments:
  80. //
  81. // Return:
  82. //
  83. bool CPersonalRangeSignaling::Init(EntityId Id)
  84. {
  85.         CRY_ASSERT(m_bInit == false);
  86.  
  87.         m_EntityId = Id;
  88.         m_bInit = true;
  89.  
  90.         // Enabled state starts off matching proxy's state
  91.         IAIActorProxy* pAIProxy = GetEntityAIProxy(m_EntityId);
  92.         SetEnabled(pAIProxy && pAIProxy->IsEnabled());
  93.  
  94.         if (GetActor() == NULL)
  95.         {
  96.                 m_bInit = false;
  97.         }
  98.         else
  99.         {
  100.                 SetListener(true);
  101.         }
  102.  
  103.         return(m_bInit);
  104. }
  105.  
  106. // Description: std::less functor template specialization, so to make comparison of two CRange pointers
  107. //                                                      work properly
  108. //
  109. // Arguments:           two pointers to CRange instances
  110. //
  111. // Return:                      comparison result
  112. //
  113. namespace std
  114. {
  115.  
  116. template<>
  117. struct less<CRange*> : public binary_function<CRange*, CRange*, bool>
  118. {
  119.         bool operator()(const CRange* pRange1, const CRange* pRange2) const
  120.         {
  121.                 CRY_ASSERT(pRange1 != NULL);
  122.                 CRY_ASSERT(pRange2 != NULL);
  123.  
  124.                 return((*pRange1) < (*pRange2));
  125.         }
  126. };
  127.  
  128. }
  129.  
  130. bool CompareRange(CRange* pRange1, CRange* pRange2)
  131. {
  132.         CRY_ASSERT(pRange1 != NULL);
  133.         CRY_ASSERT(pRange2 != NULL);
  134.  
  135.         return((*pRange1) < (*pRange2));
  136. }
  137.  
  138. bool CompareAngle(CAngleAlert* pAngle1, CAngleAlert* pAngle2)
  139. {
  140.         CRY_ASSERT(pAngle1 != NULL);
  141.         CRY_ASSERT(pAngle2 != NULL);
  142.  
  143.         return((*pAngle1) < (*pAngle2));
  144. }
  145.  
  146. // Description:
  147. //
  148. // Arguments:
  149. //
  150. // Return:
  151. //
  152. bool CPersonalRangeSignaling::AddRangeSignal(float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
  153. {
  154.         CRY_ASSERT(m_bInit == true);
  155.         CRY_ASSERT(sSignal != NULL);
  156.         CRY_ASSERT(fRadius > 0.5f);
  157.         CRY_ASSERT(fBoundary >= 0.0f);
  158.  
  159.         bool bRet = true;
  160.         CRange* pRange = SearchRange(sSignal, m_vecRanges);
  161.  
  162.         if (pRange == NULL)
  163.         {
  164.                 pRange = new CRange(this);
  165.                 m_vecRanges.push_back(pRange);
  166.         }
  167.  
  168.         pRange->Init(fRadius, fBoundary, sSignal, pData);
  169.         std::sort(m_vecRanges.begin(), m_vecRanges.end(), &CompareRange);   // std::less is properly overridden
  170.  
  171.         return(bRet);
  172. }
  173.  
  174. // Description:
  175. //
  176. // Arguments:
  177. //
  178. // Return:
  179. //
  180. bool CPersonalRangeSignaling::AddTargetRangeSignal(EntityId IdTarget, float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*= NULL*/)
  181. {
  182.         CRY_ASSERT(m_bInit == true);
  183.         CRY_ASSERT(GetActor());
  184.         CRY_ASSERT(IdTarget > 0);
  185.         CRY_ASSERT(sSignal != NULL);
  186.         CRY_ASSERT(fRadius > 0.5f);
  187.         CRY_ASSERT(fBoundary >= 0.0f);
  188.  
  189.         bool bRet = true;
  190.         CRange* pRange = SearchRange(sSignal, m_mapTargetRanges[IdTarget]);
  191.  
  192.         if (pRange == NULL)
  193.         {
  194.                 pRange = new CRange(this);
  195.                 m_mapTargetRanges[IdTarget].push_back(pRange);
  196.         }
  197.  
  198.         pRange->Init(fRadius, fBoundary, sSignal, pData);
  199.         std::sort(m_mapTargetRanges[IdTarget].begin(), m_mapTargetRanges[IdTarget].end(), &CompareRange);   // std::less is properly overridden
  200.  
  201.         return(bRet);
  202. }
  203.  
  204. // Description:
  205. //
  206. // Arguments:
  207. //
  208. // Return:
  209. //
  210. bool CPersonalRangeSignaling::AddAngleSignal(float fAngle, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
  211. {
  212.         CRY_ASSERT(m_bInit == true);
  213.         CRY_ASSERT(sSignal != NULL);
  214.         CRY_ASSERT(fAngle > 0.5f);
  215.         CRY_ASSERT(fBoundary >= 0.0f);
  216.  
  217.         bool bRet = true;
  218.         CAngleAlert* pAngle = SearchAngle(sSignal);
  219.  
  220.         if (pAngle == NULL)
  221.         {
  222.                 pAngle = new CAngleAlert(this);
  223.                 m_vecAngles.push_back(pAngle);
  224.         }
  225.  
  226.         pAngle->Init(fAngle, fBoundary, sSignal, pData);
  227.         std::sort(m_vecAngles.begin(), m_vecAngles.end(), &CompareAngle);
  228.  
  229.         return(bRet);
  230. }
  231.  
  232. // Description:
  233. //
  234. // Arguments:
  235. //
  236. // Return:
  237. //
  238. bool CPersonalRangeSignaling::Update(float fElapsedTime, uint32 uDebugOrder)
  239. {
  240.         CRY_ASSERT(m_bInit == true);
  241.  
  242.         bool bRet = false;
  243.  
  244.         if (m_bEnabled)
  245.         {
  246.                 if (uDebugOrder > 0)
  247.                 {
  248.                         DebugDraw(uDebugOrder);
  249.                 }
  250.  
  251.                 // Iterate all actors and check range to them
  252.                 IActorIteratorPtr pActorIt = CCryAction::GetCryAction()->GetIActorSystem()->CreateActorIterator();
  253.                 while (IActor* pActor = pActorIt->Next())
  254.                 {
  255.                         EntityId entityId = pActor->GetEntityId();
  256.                         if (entityId != GetEntityId())
  257.                         {
  258.                                 // Skip over if not enabled
  259.                                 IAIObject const* pAIObject = GetEntityAI(entityId);
  260.                                 if (!pAIObject || pAIObject->IsEnabled())
  261.                                 {
  262.                                         CheckActorRanges(pActor);
  263.                                         CheckActorAngles(pActor);
  264.  
  265.                                         // Do check on target ranges
  266.                                         MapTargetRanges::iterator itTargetRanges = m_mapTargetRanges.find(entityId);
  267.                                         if (itTargetRanges != m_mapTargetRanges.end())
  268.                                         {
  269.                                                 CheckActorTargetRanges(pActor);
  270.                                         }
  271.                                 }
  272.                         }
  273.                 }
  274.  
  275.                 bRet = true;
  276.         }
  277.  
  278.         return(bRet);
  279. }
  280.  
  281. // Description:
  282. //
  283. // Arguments:
  284. //
  285. // Return:
  286. //
  287. void CPersonalRangeSignaling::CheckActorRanges(IActor* pActor)
  288. {
  289.         CRY_ASSERT(pActor != NULL);
  290.  
  291.         MapRangeSignals::iterator it = m_mapRangeSignalsSent.find(pActor->GetEntityId());
  292.         CRange const* pRange = GetRangeTo(pActor->GetEntity()->GetPos(), m_vecRanges);
  293.         CRange const* pOldRange = ((it != m_mapRangeSignalsSent.end()) ? it->second : NULL);
  294.  
  295.         if (pRange != pOldRange)
  296.         {
  297.                 if (pRange != NULL)
  298.                 {
  299.                         // Check boundary
  300.                         if (GetRangeTo(pActor->GetEntity()->GetPos(), m_vecRanges, true) != pOldRange)
  301.                         {
  302.                                 if (pOldRange == NULL)
  303.                                 {
  304.                                         m_mapRangeSignalsSent.insert(std::pair<EntityId, CRange const*>(pActor->GetEntityId(), pRange));
  305.                                 }
  306.                                 else
  307.                                 {
  308.                                         it->second = pRange;
  309.                                 }
  310.  
  311.                                 SendSignal(pActor, pRange->GetSignal(), pRange->GetSignalData());
  312.                         }
  313.                 }
  314.                 else
  315.                 {
  316.                         m_mapRangeSignalsSent.erase(it);
  317.                 }
  318.         }
  319. }
  320.  
  321. // Description:
  322. //
  323. // Arguments:
  324. //
  325. // Return:
  326. //
  327. void CPersonalRangeSignaling::CheckActorTargetRanges(IActor* pActor)
  328. {
  329.         CRY_ASSERT(pActor != NULL);
  330.  
  331.         MapTargetRanges::iterator itTargetRanges = m_mapTargetRanges.find(pActor->GetEntityId());
  332.         CRY_ASSERT(itTargetRanges != m_mapTargetRanges.end());
  333.  
  334.         MapRangeSignals::iterator it = m_mapTargetRangeSignalsSent.find(pActor->GetEntityId());
  335.         CRange const* pRange = GetRangeTo(pActor->GetEntity()->GetPos(), itTargetRanges->second);
  336.         CRange const* pOldRange = ((it != m_mapTargetRangeSignalsSent.end()) ? it->second : NULL);
  337.  
  338.         if (pRange != pOldRange)
  339.         {
  340.                 if (pRange != NULL)
  341.                 {
  342.                         // Check boundary
  343.                         if (GetRangeTo(pActor->GetEntity()->GetPos(), itTargetRanges->second, true) != pOldRange)
  344.                         {
  345.                                 if (pOldRange == NULL)
  346.                                 {
  347.                                         m_mapTargetRangeSignalsSent.insert(std::pair<EntityId, CRange const*>(pActor->GetEntityId(), pRange));
  348.                                 }
  349.                                 else
  350.                                 {
  351.                                         it->second = pRange;
  352.                                 }
  353.  
  354.                                 IActor* pMe = GetActor();
  355.                                 CRY_ASSERT_MESSAGE(pMe, "An actor has been removed without cleaning up its range signals.");
  356.                                 if (pMe)
  357.                                 {
  358.                                         SendSignal(pMe, pRange->GetSignal(), pRange->GetSignalData());
  359.                                 }
  360.                         }
  361.                 }
  362.                 else
  363.                 {
  364.                         m_mapTargetRangeSignalsSent.erase(it);
  365.                 }
  366.         }
  367. }
  368.  
  369. // Description:
  370. //
  371. // Arguments:
  372. //
  373. // Return:
  374. //
  375. void CPersonalRangeSignaling::CheckActorAngles(IActor* pActor)
  376. {
  377.         CRY_ASSERT(pActor != NULL);
  378.  
  379.         MapAngleSignals::iterator it = m_mapAngleSignalsSent.find(pActor->GetEntityId());
  380.         CAngleAlert const* pAngle = GetAngleTo(pActor->GetEntity()->GetPos());
  381.         CAngleAlert const* pOldAngle = ((it != m_mapAngleSignalsSent.end()) ? it->second : NULL);
  382.  
  383.         if (pAngle != pOldAngle)
  384.         {
  385.                 if (pAngle != NULL)
  386.                 {
  387.                         // Check boundary
  388.                         if (GetAngleTo(pActor->GetEntity()->GetPos(), true) != pOldAngle)
  389.                         {
  390.                                 if (pOldAngle == NULL)
  391.                                 {
  392.                                         m_mapAngleSignalsSent.insert(std::pair<EntityId, CAngleAlert const*>(pActor->GetEntityId(), pAngle));
  393.                                 }
  394.                                 else
  395.                                 {
  396.                                         it->second = pAngle;
  397.                                 }
  398.  
  399.                                 SendSignal(pActor, pAngle->GetSignal(), pAngle->GetSignalData());
  400.                         }
  401.                 }
  402.                 else
  403.                 {
  404.                         m_mapAngleSignalsSent.erase(it);
  405.                 }
  406.         }
  407. }
  408.  
  409. // Description:
  410. //
  411. // Arguments:
  412. //
  413. // Return:
  414. //
  415. void CPersonalRangeSignaling::Reset()
  416. {
  417.         m_mapRangeSignalsSent.clear();
  418.         m_mapTargetRangeSignalsSent.clear();
  419.         m_mapAngleSignalsSent.clear();
  420.         m_mapTargetRanges.clear();
  421. }
  422.  
  423. // Description:
  424. //
  425. // Arguments:
  426. //
  427. // Return:
  428. //
  429. void CPersonalRangeSignaling::OnProxyReset()
  430. {
  431.         // Reset listener
  432.         SetListener(true);
  433. }
  434.  
  435. // Description:
  436. //
  437. // Arguments:
  438. //
  439. // Return:
  440. //
  441. void CPersonalRangeSignaling::SetEnabled(bool bEnable)
  442. {
  443.         CRY_ASSERT(m_bInit == true);
  444.  
  445.         m_bEnabled = bEnable;
  446. }
  447.  
  448. // Description:
  449. //
  450. // Arguments:
  451. //
  452. // Return:
  453. //
  454. EntityId CPersonalRangeSignaling::GetEntityId() const
  455. {
  456.         CRY_ASSERT(m_bInit == true);
  457.  
  458.         return(m_EntityId);
  459. }
  460.  
  461. // Description:
  462. //
  463. // Arguments:
  464. //
  465. // Return:
  466. //
  467. IEntity* CPersonalRangeSignaling::GetEntity()
  468. {
  469.         CRY_ASSERT(m_bInit == true);
  470.  
  471.         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
  472. }
  473.  
  474. // Description:
  475. //
  476. // Arguments:
  477. //
  478. // Return:
  479. //
  480. IEntity const* CPersonalRangeSignaling::GetEntity() const
  481. {
  482.         CRY_ASSERT(m_bInit == true);
  483.  
  484.         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
  485. }
  486.  
  487. // Description:
  488. //
  489. // Arguments:
  490. //
  491. // Return:
  492. //
  493. IActor* CPersonalRangeSignaling::GetActor()
  494. {
  495.         CRY_ASSERT(m_bInit == true);
  496.  
  497.         return(CCryAction::GetCryAction()->GetIActorSystem()->GetActor(m_EntityId));
  498. }
  499.  
  500. // Description:
  501. //
  502. // Arguments:
  503. //
  504. // Return:
  505. //
  506. void CPersonalRangeSignaling::SendSignal(IActor* pActor, const string& sSignal, IAISignalExtraData* pData /*= NULL*/) const
  507. {
  508.         CRY_ASSERT(m_bInit == true);
  509.         CRY_ASSERT(pActor != NULL);
  510.         CRY_ASSERT(sSignal.length() > 0);
  511.  
  512.         IAIObject* pAI = pActor->GetEntity()->GetAI();
  513.         //CRY_ASSERT(pAI);  Not every actor has an ai, and nor do they need it
  514.         if (pAI && gEnv->pAISystem)
  515.         {
  516.                 gEnv->pAISystem->SendSignal(SIGNALFILTER_SENDER, 1, sSignal, pAI, PrepareSignalData(pData));
  517.         }
  518. }
  519.  
  520. // Description:
  521. //
  522. // Arguments:
  523. //
  524. // Return:
  525. //
  526. IAISignalExtraData* CPersonalRangeSignaling::PrepareSignalData(IAISignalExtraData* pRequestedData) const
  527. {
  528.         IAISignalExtraData* pSendData = gEnv->pAISystem->CreateSignalExtraData();
  529.         if (pRequestedData)
  530.         {
  531.                 // Clone requested data and send it over
  532.                 *pSendData = *pRequestedData;
  533.         }
  534.         else
  535.         {
  536.                 // Send useful info
  537.                 pSendData->nID = GetEntityId();
  538.                 pSendData->point = (GetEntity() ? GetEntity()->GetWorldPos() : Vec3Constants<float>::fVec3_Zero);
  539.         }
  540.  
  541.         return (pSendData);
  542. }
  543.  
  544. // Description:
  545. //
  546. // Arguments:
  547. //
  548. // Return:
  549. //
  550. CRange const* CPersonalRangeSignaling::GetRangeTo(const Vec3& vPos, const VecRanges& vecRangeList, bool bUseBoundary) const
  551. {
  552.         IEntity const* pEntity = GetEntity();
  553.         if (!pEntity)
  554.                 return(NULL);
  555.  
  556.         CRange const* pRange = NULL;
  557.         Vec3 vOrigin = pEntity->GetPos();
  558.         float fSquaredDist = (vPos - vOrigin).GetLengthSquared();
  559.  
  560.         for (int i = 0; i < vecRangeList.size(); ++i)
  561.         {
  562.                 bool bInRange = false;
  563.  
  564.                 if (bUseBoundary == true)
  565.                 {
  566.                         bInRange = (vecRangeList[i]->IsInRangePlusBoundary(fSquaredDist) == true);
  567.                 }
  568.                 else
  569.                 {
  570.                         bInRange = (vecRangeList[i]->IsInRange(fSquaredDist) == true);
  571.                 }
  572.  
  573.                 if (bInRange == true)
  574.                 {
  575.                         pRange = vecRangeList[i];
  576.                         break;
  577.                 }
  578.         }
  579.  
  580.         return(pRange);
  581. }
  582.  
  583. // Description:
  584. //
  585. // Arguments:
  586. //
  587. // Return:
  588. //
  589. CAngleAlert const* CPersonalRangeSignaling::GetAngleTo(const Vec3& vPos, bool bUseBoundary) const
  590. {
  591.         CAngleAlert const* pAngle = NULL;
  592.         float fAngleDiff = -1.0f;
  593.  
  594.         for (int i = 0; i < m_vecAngles.size(); ++i)
  595.         {
  596.                 bool bInAngle = false;
  597.  
  598.                 if (fAngleDiff < 0.0f)
  599.                 {
  600.                         fAngleDiff = m_vecAngles[i]->GetAngleTo(vPos);
  601.                 }
  602.  
  603.                 if (bUseBoundary == true)
  604.                 {
  605.                         bInAngle = (m_vecAngles[i]->CheckPlusBoundary(fAngleDiff) == true);
  606.                 }
  607.                 else
  608.                 {
  609.                         bInAngle = (m_vecAngles[i]->Check(fAngleDiff) == true);
  610.                 }
  611.  
  612.                 if (bInAngle == true)
  613.                 {
  614.                         pAngle = m_vecAngles[i];
  615.                         break;
  616.                 }
  617.         }
  618.  
  619.         return(pAngle);
  620. }
  621.  
  622. // Description:
  623. //
  624. // Arguments:
  625. //
  626. // Return:
  627. //
  628. CRange* CPersonalRangeSignaling::SearchRange(const char* sSignal, const VecRanges& vecRangeList) const
  629. {
  630.         CRange* pRange = NULL;
  631.  
  632.         for (int i = 0; i < vecRangeList.size(); ++i)
  633.         {
  634.                 if (vecRangeList[i]->GetSignal().compareNoCase(sSignal) == 0)
  635.                 {
  636.                         pRange = vecRangeList[i];
  637.                         break;
  638.                 }
  639.         }
  640.  
  641.         return(pRange);
  642. }
  643.  
  644. // Description:
  645. //
  646. // Arguments:
  647. //
  648. // Return:
  649. //
  650. CAngleAlert* CPersonalRangeSignaling::SearchAngle(const char* sSignal) const
  651. {
  652.         CAngleAlert* pAngle = NULL;
  653.  
  654.         for (int i = 0; i < m_vecAngles.size(); ++i)
  655.         {
  656.                 if (m_vecAngles[i]->GetSignal().compareNoCase(sSignal) == 0)
  657.                 {
  658.                         pAngle = m_vecAngles[i];
  659.                         break;
  660.                 }
  661.         }
  662.  
  663.         return(pAngle);
  664. }
  665.  
  666. // Description:
  667. //
  668. // Arguments:
  669. //
  670. // Return:
  671. //
  672. void CPersonalRangeSignaling::DebugDraw(uint32 uOrder) const
  673. {
  674.         CRY_ASSERT(m_bInit == true);
  675.  
  676.         IUIDraw* pUI = CCryAction::GetCryAction()->GetIUIDraw();
  677.         float x = 120.0f;
  678.         float y = 100.0f + (float(uOrder) * 10.0f);
  679.         float r = 0.0f;
  680.         float g = 8.0f;
  681.         float b = 0.0f;
  682.  
  683.         char txt[512] = "\0";
  684.  
  685.         //cry_sprintf( txt, "%s > %s: %0.1f / %0.1f", GetActor()->GetEntity()->GetName(), m_sSignal.c_str(), m_fTimer, m_fRateMax );
  686.         pUI->DrawText(
  687.           m_pDefaultFont,
  688.           x,
  689.           y,
  690.           13.0f,
  691.           13.0f,
  692.           txt,
  693.           1.0f,
  694.           r,
  695.           g,
  696.           b,
  697.           UIDRAWHORIZONTAL_LEFT,
  698.           UIDRAWVERTICAL_TOP,
  699.           UIDRAWHORIZONTAL_LEFT,
  700.           UIDRAWVERTICAL_TOP);
  701. }
  702.  
  703. // Description:
  704. //
  705. // Arguments:
  706. //
  707. // Return:
  708. //
  709. IAIObject const* CPersonalRangeSignaling::GetEntityAI(EntityId entityId) const
  710. {
  711.         IAIObject const* pAIObject = NULL;
  712.  
  713.         IEntity* pEntity = gEnv->pEntitySystem->GetEntity(entityId);
  714.         if (pEntity)
  715.         {
  716.                 pAIObject = pEntity->GetAI();
  717.         }
  718.  
  719.         return pAIObject;
  720. }
  721.  
  722. // Description:
  723. //
  724. // Arguments:
  725. //
  726. // Return:
  727. //
  728. IAIActorProxy* CPersonalRangeSignaling::GetEntityAIProxy(EntityId entityId) const
  729. {
  730.         IAIActorProxy* pAIProxy = NULL;
  731.  
  732.         IAIObject const* pAIObject = GetEntityAI(m_EntityId);
  733.         if (pAIObject)
  734.         {
  735.                 pAIProxy = pAIObject->GetProxy();
  736.         }
  737.  
  738.         return pAIProxy;
  739. }
  740.  
  741. // Description:
  742. //
  743. // Arguments:
  744. //
  745. // Return:
  746. //
  747. void CPersonalRangeSignaling::SetListener(bool bAdd)
  748. {
  749.         CAIProxy* pAIProxy = static_cast<CAIProxy*>(GetEntityAIProxy(m_EntityId));
  750.         if (pAIProxy)
  751.         {
  752.                 if (bAdd)
  753.                         pAIProxy->AddListener(this);
  754.                 else
  755.                         pAIProxy->RemoveListener(this);
  756.         }
  757. }
  758.  
  759. // Description:
  760. //
  761. // Arguments:
  762. //
  763. // Return:
  764. //
  765. void CPersonalRangeSignaling::OnAIProxyEnabled(bool bEnabled)
  766. {
  767.         if (bEnabled)
  768.         {
  769.                 Reset();
  770.                 SetEnabled(true);
  771.         }
  772.         else
  773.         {
  774.                 SetEnabled(false);
  775.         }
  776. }
  777.  
downloadPersonalRangeSignaling.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