BVB Source Codes

CRYENGINE Show RangeSignaling.cpp Source code

Return Download CRYENGINE: download RangeSignaling.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:   RangeSignaling.cpp
  6.    $Id$
  7.    $DateTime$
  8.    Description: Signal entities based on ranges from other entities
  9.    ---------------------------------------------------------------------
  10.    History:
  11.    - 09:04:2007 : Created by Ricardo Pillosu
  12.  
  13.  *********************************************************************/
  14. #include "StdAfx.h"
  15. #include "RangeSignaling.h"
  16. #include "PersonalRangeSignaling.h"
  17.  
  18. CRangeSignaling* CRangeSignaling::m_pInstance = NULL;
  19.  
  20. // Description:
  21. //   Constructor
  22. // Arguments:
  23. //
  24. // Return:
  25. //
  26. CRangeSignaling::CRangeSignaling()
  27. {
  28.         m_bInit = false;
  29.         m_bDebug = false;
  30. }
  31.  
  32. // Description:
  33. //   Destructor
  34. // Arguments:
  35. //
  36. // Return:
  37. //
  38. CRangeSignaling::~CRangeSignaling()
  39. {
  40.         Reset();
  41. }
  42.  
  43. // Description:
  44. //   Ref
  45. // Arguments:
  46. //
  47. // Return:
  48. //
  49. CRangeSignaling& CRangeSignaling::ref()
  50. {
  51.         CRY_ASSERT(NULL != m_pInstance);
  52.         return(*m_pInstance);
  53. }
  54.  
  55. // Description:
  56. //   Create
  57. // Arguments:
  58. //
  59. // Return:
  60. //
  61. bool CRangeSignaling::Create()
  62. {
  63.         if (NULL == m_pInstance)
  64.         {
  65.                 m_pInstance = new CRangeSignaling();
  66.         }
  67.         else
  68.         {
  69.                 CRY_ASSERT("Trying to Create() the singleton more than once");
  70.         }
  71.  
  72.         return(m_pInstance != NULL);
  73. }
  74.  
  75. // Description:
  76. //
  77. // Arguments:
  78. //
  79. // Return:
  80. //
  81. void CRangeSignaling::Init()
  82. {
  83.         if (m_bInit == false)
  84.         {
  85.                 m_bInit = true;
  86.         }
  87. }
  88.  
  89. // Description:
  90. //
  91. // Arguments:
  92. //
  93. // Return:
  94. //
  95. void CRangeSignaling::Reset()
  96. {
  97.         for (MapPersonals::iterator iter = m_Personals.begin(); iter != m_Personals.end(); ++iter)
  98.         {
  99.                 CPersonalRangeSignaling* pPersonal = iter->second;
  100.                 SAFE_DELETE(pPersonal);
  101.         }
  102.  
  103.         m_Personals.clear();
  104. }
  105.  
  106. // Description:
  107. //
  108. // Arguments:
  109. //
  110. // Return:
  111. //
  112. void CRangeSignaling::OnEditorSetGameMode(bool bGameMode)
  113. {
  114.         CRY_ASSERT(m_bInit == true);
  115.  
  116.         if (bGameMode == true)
  117.         {
  118.                 Reset();
  119.         }
  120. }
  121.  
  122. // Description:
  123. //
  124. // Arguments:
  125. //
  126. // Return:
  127. //
  128. void CRangeSignaling::OnProxyReset(EntityId IdEntity)
  129. {
  130.         CRY_ASSERT(IdEntity > 0);
  131.  
  132.         MapPersonals::iterator iter = m_Personals.find(IdEntity);
  133.  
  134.         if (iter != m_Personals.end())
  135.         {
  136.                 iter->second->OnProxyReset();
  137.         }
  138. }
  139.  
  140. // Description:
  141. //
  142. // Arguments:
  143. //
  144. // Return:
  145. //
  146. bool CRangeSignaling::Update(float fElapsedTime)
  147. {
  148.         bool bRet = true;
  149.  
  150.         for (MapPersonals::iterator iter = m_Personals.begin(); iter != m_Personals.end(); ++iter)
  151.         {
  152.                 CPersonalRangeSignaling* pPersonal = iter->second;
  153.                 bRet |= pPersonal->Update(fElapsedTime);
  154.         }
  155.  
  156.         return(bRet);
  157. }
  158.  
  159. // Description:
  160. //
  161. // Arguments:
  162. //
  163. // Return:
  164. //
  165. void CRangeSignaling::Shutdown()
  166. {
  167.         SAFE_DELETE(m_pInstance);
  168. }
  169.  
  170. // Description:
  171. //
  172. // Arguments:
  173. //
  174. // Return:
  175. //
  176. void CRangeSignaling::SetDebug(bool bDebug)
  177. {
  178.         CRY_ASSERT(m_bInit == true);
  179.  
  180.         m_bDebug = bDebug;
  181. }
  182.  
  183. // Description:
  184. //
  185. // Arguments:
  186. //
  187. // Return:
  188. //
  189. bool CRangeSignaling::GetDebug() const
  190. {
  191.         return(m_bDebug);
  192. }
  193.  
  194. // Description:
  195. //
  196. // Arguments:
  197. //
  198. // Return:
  199. //
  200. bool CRangeSignaling::AddRangeSignal(EntityId IdEntity, float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
  201. {
  202.         CRY_ASSERT(m_bInit == true);
  203.         CRY_ASSERT(IdEntity > 0);
  204.         CRY_ASSERT(sSignal != NULL);
  205.         CRY_ASSERT(fRadius > 0.5f);
  206.         CRY_ASSERT(fBoundary >= 0.0f);
  207.  
  208.         bool bRet = false;
  209.         CPersonalRangeSignaling* pPersonal = GetPersonalRangeSignaling(IdEntity);
  210.  
  211.         if (pPersonal == NULL)
  212.         {
  213.                 pPersonal = CreatePersonalRangeSignaling(IdEntity);
  214.         }
  215.  
  216.         if (pPersonal != NULL)
  217.         {
  218.                 bRet = pPersonal->AddRangeSignal(fRadius, fBoundary, sSignal, pData);
  219.         }
  220.  
  221.         return(bRet);
  222. }
  223.  
  224. // Description:
  225. //
  226. // Arguments:
  227. //
  228. // Return:
  229. //
  230. bool CRangeSignaling::AddTargetRangeSignal(EntityId IdEntity, EntityId IdTarget, float fRadius, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*= NULL*/)
  231. {
  232.         CRY_ASSERT(m_bInit == true);
  233.         CRY_ASSERT(IdEntity > 0);
  234.         CRY_ASSERT(IdTarget > 0);
  235.         CRY_ASSERT(sSignal != NULL);
  236.         CRY_ASSERT(fRadius > 0.5f);
  237.         CRY_ASSERT(fBoundary >= 0.0f);
  238.  
  239.         bool bRet = false;
  240.         CPersonalRangeSignaling* pPersonal = GetPersonalRangeSignaling(IdEntity);
  241.  
  242.         if (pPersonal == NULL)
  243.         {
  244.                 pPersonal = CreatePersonalRangeSignaling(IdEntity);
  245.         }
  246.  
  247.         if (pPersonal != NULL)
  248.         {
  249.                 bRet = pPersonal->AddTargetRangeSignal(IdTarget, fRadius, fBoundary, sSignal, pData);
  250.         }
  251.  
  252.         return(bRet);
  253. }
  254.  
  255. // Description:
  256. //
  257. // Arguments:
  258. //
  259. // Return:
  260. //
  261. bool CRangeSignaling::AddAngleSignal(EntityId IdEntity, float fAngle, float fBoundary, const char* sSignal, IAISignalExtraData* pData /*=NULL*/)
  262. {
  263.         CRY_ASSERT(m_bInit == true);
  264.         CRY_ASSERT(IdEntity > 0);
  265.         CRY_ASSERT(sSignal != NULL);
  266.         CRY_ASSERT(fAngle > 0.5f);
  267.         CRY_ASSERT(fBoundary >= 0.0f);
  268.  
  269.         bool bRet = true;
  270.         CPersonalRangeSignaling* pPersonal = GetPersonalRangeSignaling(IdEntity);
  271.  
  272.         if (pPersonal == NULL)
  273.         {
  274.                 pPersonal = CreatePersonalRangeSignaling(IdEntity);
  275.         }
  276.  
  277.         bRet = pPersonal->AddAngleSignal(fAngle, fBoundary, sSignal, pData);
  278.  
  279.         return(bRet);
  280. }
  281.  
  282. // Description:
  283. //
  284. // Arguments:
  285. //
  286. // Return:
  287. //
  288. bool CRangeSignaling::DestroyPersonalRangeSignaling(EntityId IdEntity)
  289. {
  290.         CRY_ASSERT(m_bInit == true);
  291.         CRY_ASSERT(IdEntity > 0);
  292.  
  293.         return(stl::member_find_and_erase(m_Personals, IdEntity));
  294. }
  295.  
  296. // Description:
  297. //
  298. // Arguments:
  299. //
  300. // Return:
  301. //
  302. void CRangeSignaling::ResetPersonalRangeSignaling(EntityId IdEntity)
  303. {
  304.         CRY_ASSERT(m_bInit == true);
  305.         CRY_ASSERT(IdEntity > 0);
  306.  
  307.         MapPersonals::iterator iter = m_Personals.find(IdEntity);
  308.  
  309.         if (iter != m_Personals.end())
  310.         {
  311.                 iter->second->Reset();
  312.         }
  313. }
  314.  
  315. // Description:
  316. //
  317. // Arguments:
  318. //
  319. // Return:
  320. //
  321. void CRangeSignaling::EnablePersonalRangeSignaling(EntityId IdEntity, bool bEnable)
  322. {
  323.         CRY_ASSERT(m_bInit == true);
  324.         CRY_ASSERT(IdEntity > 0);
  325.  
  326.         MapPersonals::iterator iter = m_Personals.find(IdEntity);
  327.  
  328.         if (iter != m_Personals.end())
  329.         {
  330.                 iter->second->SetEnabled(bEnable);
  331.         }
  332. }
  333.  
  334. // Description:
  335. //
  336. // Arguments:
  337. //
  338. // Return:
  339. //
  340. CPersonalRangeSignaling* CRangeSignaling::GetPersonalRangeSignaling(EntityId IdEntity) const
  341. {
  342.         CRY_ASSERT(m_bInit == true);
  343.         CRY_ASSERT(IdEntity > 0);
  344.  
  345.         CPersonalRangeSignaling* pPersonal = NULL;
  346.         MapPersonals::const_iterator iter = m_Personals.find(IdEntity);
  347.  
  348.         if (iter != m_Personals.end())
  349.         {
  350.                 pPersonal = iter->second;
  351.         }
  352.  
  353.         return(pPersonal);
  354. }
  355.  
  356. // Description:
  357. //
  358. // Arguments:
  359. //
  360. // Return:
  361. //
  362. CPersonalRangeSignaling* CRangeSignaling::CreatePersonalRangeSignaling(EntityId IdEntity)
  363. {
  364.         CRY_ASSERT(m_bInit == true);
  365.         CRY_ASSERT(IdEntity > 0);
  366.  
  367.         CPersonalRangeSignaling* pPersonal = new CPersonalRangeSignaling(this);
  368.  
  369.         if (pPersonal->Init(IdEntity) == true)
  370.         {
  371.                 m_Personals.insert(std::pair<EntityId, CPersonalRangeSignaling*>(IdEntity, pPersonal));
  372.         }
  373.         else
  374.         {
  375.                 SAFE_DELETE(pPersonal);
  376.         }
  377.  
  378.         return(pPersonal);
  379. }
  380.  
downloadRangeSignaling.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