BVB Source Codes

CRYENGINE Show PersonalSignalTimer.cpp Source code

Return Download CRYENGINE: download PersonalSignalTimer.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:   PersonalSignalTimer.cpp
  6.    $Id$
  7.    $DateTime$
  8.    Description: Manager per-actor signal timers
  9.    ---------------------------------------------------------------------
  10.    History:
  11.    - 07:05:2007 : Created by Ricardo Pillosu
  12.  
  13.  *********************************************************************/
  14. #include "StdAfx.h"
  15. #include "PersonalSignalTimer.h"
  16. #include "SignalTimers.h"
  17. #include "IUIDraw.h"
  18. #include <CryAISystem/IAIObject.h>
  19. // Description:
  20. //   Constructor
  21. // Arguments:
  22. //
  23. // Return:
  24. //
  25. CPersonalSignalTimer::CPersonalSignalTimer(CSignalTimer* pParent) :
  26.         m_bInit(false),
  27.         m_pParent(pParent),
  28.         m_EntityId(0),
  29.         m_fRateMin(4.0f),
  30.         m_fRateMax(6.0f),
  31.         m_fTimer(0.0f),
  32.         m_bEnabled(false),
  33.         m_fTimerSinceLastReset(0.0f),
  34.         m_iSignalsSinceLastReset(0)
  35. {
  36.         CRY_ASSERT(pParent != NULL);
  37.  
  38.         m_pDefaultFont = gEnv->pCryFont->GetFont("default");
  39.         CRY_ASSERT(m_pDefaultFont);
  40. }
  41.  
  42. // Description:
  43. //   Destructor
  44. // Arguments:
  45. //
  46. // Return:
  47. //
  48. CPersonalSignalTimer::~CPersonalSignalTimer()
  49. {
  50.         SetListener(false);
  51. }
  52.  
  53. // Description:
  54. //
  55. // Arguments:
  56. //
  57. // Return:
  58. //
  59. bool CPersonalSignalTimer::Init(EntityId Id, const char* sSignal)
  60. {
  61.         CRY_ASSERT(m_bInit == false);
  62.         CRY_ASSERT(sSignal != NULL);
  63.  
  64.         m_EntityId = Id;
  65.         m_sSignal = sSignal;
  66.         m_bInit = true;
  67.         SetListener(true);
  68.  
  69.         return(m_bInit);
  70. }
  71.  
  72. // Description:
  73. //
  74. // Arguments:
  75. //
  76. // Return:
  77. //
  78. bool CPersonalSignalTimer::Update(float fElapsedTime, uint32 uDebugOrder)
  79. {
  80.         CRY_ASSERT(m_bInit == true);
  81.  
  82.         bool bRet = true;
  83.         if (m_bEnabled == true)
  84.         {
  85.                 m_fTimer -= fElapsedTime;
  86.                 m_fTimerSinceLastReset += fElapsedTime;
  87.  
  88.                 if (m_fTimer < 0.0f)
  89.                 {
  90.                         SendSignal();
  91.                         Reset();
  92.                 }
  93.         }
  94.  
  95.         if (uDebugOrder > 0)
  96.         {
  97.                 DebugDraw(uDebugOrder);
  98.         }
  99.  
  100.         return(bRet);
  101. }
  102.  
  103. // Description:
  104. //
  105. // Arguments:
  106. //
  107. // Return:
  108. //
  109. void CPersonalSignalTimer::ForceReset(bool bAlsoEnable)
  110. {
  111.         CRY_ASSERT(m_bInit == true);
  112.  
  113.         m_fTimerSinceLastReset = 0.0f;
  114.         m_iSignalsSinceLastReset = 0;
  115.         Reset(bAlsoEnable);
  116. }
  117.  
  118. // Description:
  119. //
  120. // Arguments:
  121. //
  122. // Return:
  123. //
  124. void CPersonalSignalTimer::OnProxyReset()
  125. {
  126.         // Reset listener
  127.         SetListener(true);
  128. }
  129.  
  130. // Description:
  131. //
  132. // Arguments:
  133. //
  134. // Return:
  135. //
  136. void CPersonalSignalTimer::Reset(bool bAlsoEnable)
  137. {
  138.         CRY_ASSERT(m_bInit == true);
  139.  
  140.         if (m_fRateMin < m_fRateMax)
  141.         {
  142.                 m_fTimer = cry_random(m_fRateMin, m_fRateMax);
  143.         }
  144.         else
  145.         {
  146.                 m_fTimer = m_fRateMin;
  147.         }
  148.  
  149.         SetEnabled(bAlsoEnable);
  150. }
  151.  
  152. // Description:
  153. //
  154. // Arguments:
  155. //
  156. // Return:
  157. //
  158. EntityId CPersonalSignalTimer::GetEntityId() const
  159. {
  160.         CRY_ASSERT(m_bInit == true);
  161.  
  162.         return(m_EntityId);
  163. }
  164.  
  165. // Description:
  166. //
  167. // Arguments:
  168. //
  169. // Return:
  170. //
  171. const string& CPersonalSignalTimer::GetSignalString() const
  172. {
  173.         CRY_ASSERT(m_bInit == true);
  174.  
  175.         return(m_sSignal);
  176. }
  177.  
  178. // Description:
  179. //
  180. // Arguments:
  181. //
  182. // Return:
  183. //
  184. IEntity* CPersonalSignalTimer::GetEntity()
  185. {
  186.         CRY_ASSERT(m_bInit == true);
  187.  
  188.         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
  189. }
  190.  
  191. // Description:
  192. //
  193. // Arguments:
  194. //
  195. // Return:
  196. //
  197. IEntity const* CPersonalSignalTimer::GetEntity() const
  198. {
  199.         CRY_ASSERT(m_bInit == true);
  200.  
  201.         return(gEnv->pEntitySystem->GetEntity(m_EntityId));
  202. }
  203.  
  204. // Description:
  205. //
  206. // Arguments:
  207. //
  208. // Return:
  209. //
  210. void CPersonalSignalTimer::SetRate(float fNewRateMin, float fNewRateMax)
  211. {
  212.         CRY_ASSERT(m_bInit == true);
  213.         CRY_ASSERT(fNewRateMin > 0.0f);
  214.         CRY_ASSERT(fNewRateMax > 0.0f);
  215.  
  216.         m_fRateMin = fNewRateMin;
  217.         m_fRateMax = max(fNewRateMin, fNewRateMax);
  218. }
  219.  
  220. // Description:
  221. //
  222. // Arguments:
  223. //
  224. // Return:
  225. //
  226. void CPersonalSignalTimer::SendSignal()
  227. {
  228.         CRY_ASSERT(m_bInit == true);
  229.  
  230.         IEntity* pEntity = GetEntity();
  231.         if (pEntity && gEnv->pAISystem)
  232.         {
  233.                 IAISignalExtraData* pData = gEnv->pAISystem->CreateSignalExtraData();
  234.                 pData->iValue = ++m_iSignalsSinceLastReset;
  235.                 pData->fValue = m_fTimerSinceLastReset;
  236.  
  237.                 gEnv->pAISystem->SendSignal(SIGNALFILTER_SENDER, 1, m_sSignal, pEntity->GetAI(), pData);
  238.         }
  239. }
  240.  
  241. // Description:
  242. //
  243. // Arguments:
  244. //
  245. // Return:
  246. //
  247. void CPersonalSignalTimer::SetEnabled(bool bEnabled)
  248. {
  249.         CRY_ASSERT(m_bInit == true);
  250.  
  251.         if (bEnabled != m_bEnabled)
  252.         {
  253.                 m_fTimerSinceLastReset = 0.0f;
  254.                 m_iSignalsSinceLastReset = 0;
  255.                 m_bEnabled = bEnabled;
  256.                 if (m_pParent->GetDebug() == true)
  257.                 {
  258.                         gEnv->pLog->Log(
  259.                           "PersonalSignalTimer [%d]: Signal [%s] is %s",
  260.                           m_EntityId,
  261.                           m_sSignal.c_str(),
  262.                           (bEnabled) ? "enabled" : "disabled");
  263.                 }
  264.         }
  265. }
  266.  
  267. // Description:
  268. //
  269. // Arguments:
  270. //
  271. // Return:
  272. //
  273. void CPersonalSignalTimer::DebugDraw(uint32 uOrder) const
  274. {
  275.         CRY_ASSERT(m_bInit == true);
  276.  
  277.         IUIDraw* pUI = CCryAction::GetCryAction()->GetIUIDraw();
  278.         float x = 120.0f;
  279.         float y = 100.0f + (float(uOrder) * 10.0f);
  280.         float r = 0.0f;
  281.         float g = 8.0f;
  282.         float b = 0.0f;
  283.  
  284.         char txt[512] = "\0";
  285.         if (GetEntity())
  286.                 cry_sprintf(txt, "%s > %s: %0.1f / %0.1f", GetEntity()->GetName(), m_sSignal.c_str(), m_fTimer, m_fRateMax);
  287.  
  288.         if (m_bEnabled == false)
  289.         {
  290.                 r = 8.0f;
  291.                 g = b = 0.0f;
  292.         }
  293.         else if (m_fTimer < 0.5f)
  294.         {
  295.                 r = g = 8.0f;
  296.                 b = 0.0f;
  297.         }
  298.  
  299.         pUI->DrawText(
  300.           m_pDefaultFont,
  301.           x,
  302.           y,
  303.           13.0f,
  304.           13.0f,
  305.           txt,
  306.           1.0f,
  307.           r,
  308.           g,
  309.           b,
  310.           UIDRAWHORIZONTAL_LEFT,
  311.           UIDRAWVERTICAL_TOP,
  312.           UIDRAWHORIZONTAL_LEFT,
  313.           UIDRAWVERTICAL_TOP);
  314. }
  315.  
  316. // Description:
  317. //
  318. // Arguments:
  319. //
  320. // Return:
  321. //
  322. void CPersonalSignalTimer::SetListener(bool bAdd)
  323. {
  324.         IEntity* pEntity = GetEntity();
  325.         ;
  326.         if (pEntity)
  327.         {
  328.                 IAIObject* pAIObject = pEntity->GetAI();
  329.                 if (pAIObject)
  330.                 {
  331.                         CAIProxy* pAIProxy = (CAIProxy*)pAIObject->GetProxy();
  332.                         if (pAIProxy)
  333.                         {
  334.                                 if (bAdd)
  335.                                         pAIProxy->AddListener(this);
  336.                                 else
  337.                                         pAIProxy->RemoveListener(this);
  338.                         }
  339.                 }
  340.         }
  341. }
  342.  
  343. // Description:
  344. //
  345. // Arguments:
  346. //
  347. // Return:
  348. //
  349. void CPersonalSignalTimer::OnAIProxyEnabled(bool bEnabled)
  350. {
  351.         if (bEnabled)
  352.         {
  353.                 ForceReset();
  354.                 SetEnabled(true);
  355.         }
  356.         else
  357.         {
  358.                 SetEnabled(false);
  359.         }
  360. }
  361.  
downloadPersonalSignalTimer.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