BVB Source Codes

CRYENGINE Show SignalTimers.cpp Source code

Return Download CRYENGINE: download SignalTimers.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:   SignalTimer.h
  6.    $Id$
  7.    $DateTime$
  8.    Description: Signal entities based on configurable timers
  9.    ---------------------------------------------------------------------
  10.    History:
  11.    - 16:04:2007 : Created by Ricardo Pillosu
  12.  
  13.  *********************************************************************/
  14. #include "StdAfx.h"
  15. #include "SignalTimers.h"
  16. #include "PersonalSignalTimer.h"
  17.  
  18. CSignalTimer* CSignalTimer::m_pInstance = NULL;
  19.  
  20. // Description:
  21. //   Constructor
  22. // Arguments:
  23. //
  24. // Return:
  25. //
  26. CSignalTimer::CSignalTimer()
  27. {
  28.         m_bInit = false;
  29.         m_bDebug = false;
  30. }
  31.  
  32. // Description:
  33. //   Destructor
  34. // Arguments:
  35. //
  36. // Return:
  37. //
  38. CSignalTimer::~CSignalTimer()
  39. {
  40.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  41.         {
  42.                 SAFE_DELETE(m_vecPersonalSignalTimers[uIndex]);
  43.         }
  44.  
  45.         m_vecPersonalSignalTimers.clear();
  46. }
  47.  
  48. // Description:
  49. //   Create
  50. // Arguments:
  51. //
  52. // Return:
  53. //
  54. CSignalTimer& CSignalTimer::ref()
  55. {
  56.         CRY_ASSERT(NULL != m_pInstance);
  57.         return(*m_pInstance);
  58. }
  59.  
  60. // Description:
  61. //   Create
  62. // Arguments:
  63. //
  64. // Return:
  65. //
  66. bool CSignalTimer::Create()
  67. {
  68.         if (NULL == m_pInstance)
  69.         {
  70.                 m_pInstance = new CSignalTimer();
  71.         }
  72.         else
  73.         {
  74.                 CRY_ASSERT("Trying to Create() the singleton more than once");
  75.         }
  76.  
  77.         return(m_pInstance != NULL);
  78. }
  79.  
  80. // Description:
  81. //
  82. // Arguments:
  83. //
  84. // Return:
  85. //
  86. void CSignalTimer::Init()
  87. {
  88.         if (m_bInit == false)
  89.         {
  90.                 m_bInit = true;
  91.         }
  92. }
  93.  
  94. // Description:
  95. //
  96. // Arguments:
  97. //
  98. // Return:
  99. //
  100. void CSignalTimer::Reset()
  101. {
  102.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  103.         {
  104.                 m_vecPersonalSignalTimers[uIndex]->ForceReset(false);
  105.         }
  106. }
  107.  
  108. // Description:
  109. //
  110. // Arguments:
  111. //
  112. // Return:
  113. //
  114. void CSignalTimer::OnEditorSetGameMode(bool bGameMode)
  115. {
  116.         CRY_ASSERT(m_bInit == true);
  117.  
  118.         if (bGameMode == true)
  119.         {
  120.                 Reset();
  121.         }
  122. }
  123.  
  124. // Description:
  125. //
  126. // Arguments:
  127. //
  128. // Return:
  129. //
  130. void CSignalTimer::OnProxyReset(EntityId IdEntity)
  131. {
  132.         CRY_ASSERT(IdEntity > 0);
  133.  
  134.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  135.         {
  136.                 if (m_vecPersonalSignalTimers[uIndex]->GetEntityId() == IdEntity)
  137.                 {
  138.                         m_vecPersonalSignalTimers[uIndex]->OnProxyReset();
  139.                 }
  140.         }
  141. }
  142.  
  143. // Description:
  144. //
  145. // Arguments:
  146. //
  147. // Return:
  148. //
  149. bool CSignalTimer::Update(float fElapsedTime)
  150. {
  151.         bool bRet = true;
  152.         uint32 uOrder = 0;
  153.         std::vector<CPersonalSignalTimer*>::iterator iter = m_vecPersonalSignalTimers.begin();
  154.  
  155.         while (iter != m_vecPersonalSignalTimers.end())
  156.         {
  157.                 CPersonalSignalTimer* pPersonal = *iter;
  158.  
  159.                 if (pPersonal && pPersonal->Update(fElapsedTime, ((m_bDebug == true) ? ++uOrder : 0)) == false)
  160.                 {
  161.                         SAFE_DELETE(pPersonal);
  162.                         iter = m_vecPersonalSignalTimers.erase(iter);
  163.                 }
  164.                 else
  165.                 {
  166.                         ++iter;
  167.                 }
  168.         }
  169.  
  170.         return(bRet);
  171. }
  172.  
  173. // Description:
  174. //
  175. // Arguments:
  176. //
  177. // Return:
  178. //
  179. void CSignalTimer::Shutdown()
  180. {
  181.         SAFE_DELETE(m_pInstance);
  182. }
  183.  
  184. // Description:
  185. //
  186. // Arguments:
  187. //
  188. // Return:
  189. //
  190. bool CSignalTimer::EnablePersonalManager(EntityId IdEntity, const char* sSignal)
  191. {
  192.         CRY_ASSERT(m_bInit == true);
  193.         CRY_ASSERT(IdEntity > 0);
  194.         CRY_ASSERT(sSignal != NULL);
  195.  
  196.         bool bRet = true;
  197.         CPersonalSignalTimer* pPersonal = GetPersonalSignalTimer(IdEntity, sSignal);
  198.  
  199.         if (pPersonal == NULL)
  200.         {
  201.                 pPersonal = CreatePersonalSignalTimer(IdEntity, sSignal);
  202.                 bRet = false;
  203.         }
  204.  
  205.         pPersonal->SetEnabled(true);
  206.  
  207.         return(bRet);
  208. }
  209.  
  210. // Description:
  211. //
  212. // Arguments:
  213. //
  214. // Return:
  215. //
  216. bool CSignalTimer::DisablePersonalSignalTimer(EntityId IdEntity, const char* sSignal)
  217. {
  218.         CRY_ASSERT(m_bInit == true);
  219.         CRY_ASSERT(IdEntity > 0);
  220.         CRY_ASSERT(sSignal != NULL);
  221.  
  222.         bool bRet = false;
  223.         CPersonalSignalTimer* pPersonal = GetPersonalSignalTimer(IdEntity, sSignal);
  224.  
  225.         if (pPersonal != NULL)
  226.         {
  227.                 pPersonal->SetEnabled(false);
  228.                 bRet = true;
  229.         }
  230.  
  231.         return(bRet);
  232. }
  233.  
  234. // Description:
  235. //
  236. // Arguments:
  237. //
  238. // Return:
  239. //
  240. bool CSignalTimer::ResetPersonalTimer(EntityId IdEntity, const char* sSignal)
  241. {
  242.         CRY_ASSERT(m_bInit == true);
  243.         CRY_ASSERT(IdEntity > 0);
  244.         CRY_ASSERT(sSignal != NULL);
  245.  
  246.         bool bRet = false;
  247.         CPersonalSignalTimer* pPersonal = GetPersonalSignalTimer(IdEntity, sSignal);
  248.  
  249.         if (pPersonal != NULL)
  250.         {
  251.                 pPersonal->ForceReset();
  252.                 bRet = true;
  253.         }
  254.  
  255.         return(bRet);
  256. }
  257.  
  258. // Description:
  259. //
  260. // Arguments:
  261. //
  262. // Return:
  263. //
  264. bool CSignalTimer::EnableAllPersonalManagers(EntityId IdEntity)
  265. {
  266.         CRY_ASSERT(m_bInit == true);
  267.         CRY_ASSERT(IdEntity > 0);
  268.  
  269.         bool bRet = false;
  270.  
  271.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  272.         {
  273.                 if (m_vecPersonalSignalTimers[uIndex]->GetEntityId() == IdEntity)
  274.                 {
  275.                         m_vecPersonalSignalTimers[uIndex]->SetEnabled(true);
  276.                         bRet = true;
  277.                 }
  278.         }
  279.  
  280.         return(bRet);
  281. }
  282.  
  283. // Description:
  284. //
  285. // Arguments:
  286. //
  287. // Return:
  288. //
  289. bool CSignalTimer::DisablePersonalSignalTimers(EntityId IdEntity)
  290. {
  291.         CRY_ASSERT(m_bInit == true);
  292.         CRY_ASSERT(IdEntity > 0);
  293.  
  294.         bool bRet = false;
  295.  
  296.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  297.         {
  298.                 if (m_vecPersonalSignalTimers[uIndex]->GetEntityId() == IdEntity)
  299.                 {
  300.                         m_vecPersonalSignalTimers[uIndex]->SetEnabled(false);
  301.                         bRet = true;
  302.                 }
  303.         }
  304.  
  305.         return(bRet);
  306. }
  307.  
  308. // Description:
  309. //
  310. // Arguments:
  311. //
  312. // Return:
  313. //
  314. bool CSignalTimer::ResetPersonalTimers(EntityId IdEntity)
  315. {
  316.         CRY_ASSERT(m_bInit == true);
  317.         CRY_ASSERT(IdEntity > 0);
  318.  
  319.         bool bRet = false;
  320.  
  321.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  322.         {
  323.                 if (m_vecPersonalSignalTimers[uIndex]->GetEntityId() == IdEntity)
  324.                 {
  325.                         m_vecPersonalSignalTimers[uIndex]->ForceReset();
  326.                         bRet = true;
  327.                 }
  328.         }
  329.  
  330.         return(bRet);
  331. }
  332.  
  333. // Description:
  334. //
  335. // Arguments:
  336. //
  337. // Return:
  338. //
  339. bool CSignalTimer::SetTurnRate(EntityId IdEntity, const char* sSignal, float fTime, float fTimeMax)
  340. {
  341.         CRY_ASSERT(m_bInit == true);
  342.         CRY_ASSERT(IdEntity > 0);
  343.         CRY_ASSERT(fTime > 0.0f);
  344.         CRY_ASSERT(sSignal != NULL);
  345.  
  346.         bool bRet = false;
  347.         CPersonalSignalTimer* pPersonal = GetPersonalSignalTimer(IdEntity, sSignal);
  348.  
  349.         if (pPersonal != NULL)
  350.         {
  351.                 pPersonal->SetRate(fTime, max(fTimeMax, fTime));
  352.                 pPersonal->ForceReset();
  353.                 bRet = true;
  354.         }
  355.  
  356.         return(bRet);
  357. }
  358.  
  359. // Description:
  360. //
  361. // Arguments:
  362. //
  363. // Return:
  364. //
  365. CPersonalSignalTimer* CSignalTimer::GetPersonalSignalTimer(EntityId IdEntity, const char* sSignal) const
  366. {
  367.         CRY_ASSERT(m_bInit == true);
  368.         CRY_ASSERT(IdEntity > 0);
  369.         CRY_ASSERT(sSignal != NULL);
  370.  
  371.         CPersonalSignalTimer* pPersonal = NULL;
  372.  
  373.         for (uint32 uIndex = 0; uIndex < m_vecPersonalSignalTimers.size(); ++uIndex)
  374.         {
  375.                 if (m_vecPersonalSignalTimers[uIndex]->GetEntityId() == IdEntity &&
  376.                     m_vecPersonalSignalTimers[uIndex]->GetSignalString().compareNoCase(sSignal) == 0)
  377.                 {
  378.                         pPersonal = m_vecPersonalSignalTimers[uIndex];
  379.                         break;
  380.                 }
  381.         }
  382.  
  383.         return(pPersonal);
  384. }
  385.  
  386. // Description:
  387. //
  388. // Arguments:
  389. //
  390. // Return:
  391. //
  392. void CSignalTimer::SetDebug(bool bDebug)
  393. {
  394.         CRY_ASSERT(m_bInit == true);
  395.  
  396.         m_bDebug = bDebug;
  397. }
  398.  
  399. // Description:
  400. //
  401. // Arguments:
  402. //
  403. // Return:
  404. //
  405. bool CSignalTimer::GetDebug() const
  406. {
  407.         return(m_bDebug);
  408. }
  409.  
  410. // Description:
  411. //
  412. // Arguments:
  413. //
  414. // Return:
  415. //
  416. CPersonalSignalTimer* CSignalTimer::CreatePersonalSignalTimer(EntityId IdEntity, const char* sSignal)
  417. {
  418.         CRY_ASSERT(m_bInit == true);
  419.         CRY_ASSERT(IdEntity > 0);
  420.         CRY_ASSERT(sSignal != NULL);
  421.  
  422.         CPersonalSignalTimer* pPersonal = new CPersonalSignalTimer(this);
  423.  
  424.         if (pPersonal->Init(IdEntity, sSignal) == true)
  425.         {
  426.                 m_vecPersonalSignalTimers.push_back(pPersonal);
  427.         }
  428.         else
  429.         {
  430.                 SAFE_DELETE(pPersonal);
  431.         }
  432.  
  433.         return(pPersonal);
  434. }
  435.  
downloadSignalTimers.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