BVB Source Codes

CRYENGINE Show UnitImg.cpp Source code

Return Download CRYENGINE: download UnitImg.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:   UnitAction.cpp
  6.    $Id$
  7.    Description: Refactoring CLeadeActions; adding Serialization support
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 22/05/2006 : Moved from UnitAction by Mikko
  12.  
  13.  *********************************************************************/
  14.  
  15. #include "StdAfx.h"
  16. #include "CAISystem.h"
  17. #include "UnitImg.h"
  18. #include "UnitAction.h"
  19. #include "AILog.h"
  20. #include "Leader.h"
  21.  
  22. CUnitImg::CUnitImg() :
  23.         m_TagPoint(0, 0, 0),
  24.         m_Group(0),
  25.         m_FormationPointIndex(0),
  26.         m_SoldierClass(UNIT_CLASS_INFANTRY),
  27.         m_properties(UPR_ALL),
  28.         m_pCurrentAction(0),
  29.         m_bTaskSuspended(false),
  30.         m_flags(0),
  31.         m_fHeight(1.6f),
  32.         m_fWidth(0.6f),
  33.         m_fDistance(0.f),
  34.         m_fDistance2(0.f),
  35.         m_lastReinforcementTime(0.f)
  36. {
  37.         // Empty
  38. }
  39.  
  40. //
  41. //----------------------------------------------------------------------------------------------------
  42. CUnitImg::CUnitImg(CWeakRef<CAIActor> refUnit) :
  43.         m_refUnit(refUnit),
  44.         m_TagPoint(0, 0, 0),
  45.         m_Group(0),
  46.         m_FormationPointIndex(0),
  47.         m_SoldierClass(UNIT_CLASS_INFANTRY),
  48.         m_properties(UPR_ALL),
  49.         m_pCurrentAction(0),
  50.         m_bTaskSuspended(false),
  51.         m_flags(0),
  52.         m_fHeight(1.6f),
  53.         m_fWidth(0.6f),
  54.         m_fDistance(0.f),
  55.         m_fDistance2(0.f),
  56.         m_lastReinforcementTime(0.f)
  57. {
  58.         m_lastMoveTime = GetAISystem()->GetFrameStartTime();
  59.  
  60.         CCCPOINT(CUnitImg_CUnitImg);
  61. }
  62.  
  63. //
  64. //----------------------------------------------------------------------------------------------------
  65. CUnitImg::~CUnitImg()
  66. {
  67.         ClearPlanning();
  68. }
  69.  
  70. //
  71. //----------------------------------------------------------------------------------------------------
  72. void CUnitImg::TaskExecuted()
  73. {
  74.  
  75.         if (m_pCurrentAction)
  76.         {
  77.                 delete m_pCurrentAction;
  78.                 m_pCurrentAction = NULL;
  79.  
  80.                 if (!m_Plan.empty())//this test should be useless
  81.                         m_Plan.pop_front();
  82.  
  83.                 CCCPOINT(CUnitImg_TaskExecuted);
  84.         }
  85. }
  86.  
  87. //
  88. //----------------------------------------------------------------------------------------------------
  89. void CUnitImg::ExecuteTask()
  90. {
  91.         bool bContinue = true;
  92.  
  93.         while (bContinue && !m_Plan.empty())
  94.         {
  95.                 CUnitAction* const nextAction = m_Plan.front();
  96.  
  97.                 bool bIsBlocked = nextAction->IsBlocked();
  98.                 bContinue = !nextAction->m_BlockingPlan && !bIsBlocked;
  99.  
  100.                 CAIActor* const pUnit = m_refUnit.GetAIObject();
  101.  
  102.                 if (!bIsBlocked)
  103.                 {
  104.                         CCCPOINT(CUnitImg_ExecuteTask);
  105.  
  106.                         m_pCurrentAction = nextAction;
  107.                         IAISignalExtraData* pData = NULL;
  108.                         switch (m_pCurrentAction->m_Action)
  109.                         {
  110.                         case UA_SIGNAL:
  111.                                 GetAISystem()->SendSignal(0, 1, m_pCurrentAction->m_SignalText, pUnit, new AISignalExtraData(m_pCurrentAction->m_SignalData));
  112.                                 break;
  113.                         case UA_ACQUIRETARGET:
  114.                                 GetAISystem()->SendSignal(0, 1, "ORDER_ACQUIRE_TARGET", pUnit, new AISignalExtraData(m_pCurrentAction->m_SignalData));
  115.                                 break;
  116.                         case UA_SEARCH:
  117.                                 {
  118.                                         const char* signal = "ORDER_SEARCH";
  119.                                         if (m_pCurrentAction->m_Point.IsZero())
  120.                                         {
  121.                                                 Vec3 hidePosition(0, 0, 0);
  122.                                                 CLeader* pMyLeader = GetAISystem()->GetLeader(pUnit);
  123.                                                 if (pMyLeader)
  124.                                                 {
  125.                                                         if (pMyLeader->m_pFormation)
  126.                                                         {
  127.                                                                 CAIObject* pFormPoint = pMyLeader->GetNewFormationPoint(m_refUnit).GetAIObject();
  128.                                                                 if (pFormPoint)
  129.                                                                         hidePosition = pFormPoint->GetPos();
  130.                                                         }
  131.                                                 }
  132.                                                 if (hidePosition.IsZero())
  133.                                                         hidePosition = pUnit->GetPos();
  134.                                                 pData = GetAISystem()->CreateSignalExtraData();
  135.                                                 pData->point = hidePosition;
  136.                                                 pData->iValue = m_pCurrentAction->m_Tag;
  137.                                                 GetAISystem()->SendSignal(0, 10, signal, pUnit, pData);
  138.  
  139.                                                 CCCPOINT(CUnitImg_TaskExecuted_A);
  140.                                         }
  141.                                         else
  142.                                         {
  143.                                                 pData = GetAISystem()->CreateSignalExtraData();
  144.                                                 pData->point = m_pCurrentAction->m_Point;
  145.                                                 pData->point2 = m_pCurrentAction->m_Direction;
  146.                                                 pData->iValue = m_pCurrentAction->m_Tag;
  147.                                                 GetAISystem()->SendSignal(0, 10, signal, pUnit, pData);
  148.                                         }
  149.                                         bContinue = false; // force blocking
  150.                                 }
  151.                                 break;
  152.                         default:
  153.                                 // unrecognized action type, skip it
  154.                                 AIAssert(0);
  155.                                 bContinue = true;
  156.                                 break;
  157.                         }
  158.                 }
  159.  
  160.                 if (bContinue)
  161.                         TaskExecuted();
  162.         }
  163. }
  164.  
  165. //
  166. //----------------------------------------------------------------------------------------------------
  167. bool CUnitImg::IsBlocked() const
  168. {
  169.         if (m_bTaskSuspended) // consider the unit's plan blocked if he's suspended his task for
  170.                 return true;        // something more prioritary
  171.  
  172.         if (m_Plan.empty())
  173.                 return false;
  174.         else
  175.                 return m_Plan.front()->IsBlocked();
  176. }
  177.  
  178. //
  179. //----------------------------------------------------------------------------------------------------
  180. void CUnitImg::ClearPlanning(int priority)
  181. {
  182.         if (priority)
  183.         {
  184.                 TActionList::iterator itAction = m_Plan.begin();
  185.                 while (itAction != m_Plan.end())
  186.                 {
  187.                         if ((*itAction)->m_Priority <= priority)
  188.                         {
  189.                                 if (*itAction == m_pCurrentAction)
  190.                                 {
  191.                                         m_pCurrentAction = NULL;
  192.                                         m_bTaskSuspended = false;
  193.                                 }
  194.  
  195.                                 CUnitAction* pAction = *itAction;
  196.                                 m_Plan.erase(itAction++);
  197.                                 delete pAction;
  198.                         }
  199.                         else
  200.                                 ++itAction;
  201.                 }
  202.         }
  203.         else // unconditioned if priority==0
  204.         {
  205.                 for (TActionList::iterator itAction = m_Plan.begin(); itAction != m_Plan.end(); ++itAction)
  206.                         delete (*itAction);
  207.                 m_Plan.clear();
  208.                 m_pCurrentAction = NULL;
  209.                 m_bTaskSuspended = false;
  210.         }
  211.  
  212. }
  213.  
  214. //
  215. //----------------------------------------------------------------------------------------------------
  216. void CUnitImg::ClearUnitAction(EUnitAction action)
  217. {
  218.         TActionList::iterator itAction = m_Plan.begin();
  219.         while (itAction != m_Plan.end())
  220.         {
  221.                 if ((*itAction)->m_Action == action)
  222.                 {
  223.                         if (*itAction == m_pCurrentAction)
  224.                         {
  225.                                 m_pCurrentAction = NULL;
  226.                                 m_bTaskSuspended = false;
  227.                         }
  228.  
  229.                         CUnitAction* pAction = *itAction;
  230.                         m_Plan.erase(itAction++);
  231.                         delete pAction;
  232.                 }
  233.                 else
  234.                         ++itAction;
  235.         }
  236. }
  237.  
  238. //
  239. //----------------------------------------------------------------------------------------------------
  240. void CUnitImg::SuspendTask()
  241. {
  242.         m_bTaskSuspended = true;
  243. }
  244.  
  245. //
  246. //----------------------------------------------------------------------------------------------------
  247. void CUnitImg::ResumeTask()
  248. {
  249.         m_bTaskSuspended = false;
  250. }
  251.  
  252. bool CUnitImg::IsPlanFinished() const
  253. {
  254.         return m_Plan.empty() || !m_refUnit.GetAIObject()->IsEnabled();
  255. }
  256.  
  257. //
  258. //----------------------------------------------------------------------------------------------------
  259. void CUnitImg::Reset()
  260. {
  261.         m_lastReinforcementTime.SetSeconds(0.f);
  262. }
  263.  
  264. //
  265. //----------------------------------------------------------------------------------------------------
  266. void CUnitImg::Serialize(TSerialize ser)
  267. {
  268.         m_refUnit.Serialize(ser, "m_refUnit");
  269.  
  270.         CRY_ASSERT_MESSAGE(m_Plan.empty(), "Todo: implement serialization of m_Plan");
  271.         //SerializeListOfPointers(ser, objectTracker, "Plan", m_Plan);
  272.         ser.Value("m_TagPoint", m_TagPoint);
  273.         ser.Value("m_flags", m_flags);
  274.         ser.Value("m_Group", m_Group);
  275.         ser.Value("m_FormationPointIndex", m_FormationPointIndex);
  276.         ser.Value("m_SoldierClass", m_SoldierClass);
  277.         ser.Value("m_bTaskSuspended", m_bTaskSuspended);
  278.         ser.Value("m_lastMoveTime", m_lastMoveTime);
  279.         ser.Value("m_fDistance", m_fDistance);
  280.         ser.Value("m_fDistance2", m_fDistance2);
  281.         ser.Value("m_lastReinforcementTime", m_lastReinforcementTime);
  282.  
  283.         if (ser.BeginOptionalGroup("CurrentAction", m_pCurrentAction != NULL))
  284.         {
  285.                 if (ser.IsReading())
  286.                         m_pCurrentAction = m_Plan.empty() ? NULL : m_Plan.front();
  287.                 ser.EndGroup();
  288.         }
  289. }
  290.  
  291. //
  292. //----------------------------------------------------------------------------------------------------
  293. void CUnitAction::Serialize(TSerialize ser)
  294. {
  295.         ser.EnumValue("m_Action", m_Action, UA_NONE, UA_LAST);
  296.         ser.Value("m_BlockingPlan", m_BlockingPlan);
  297.  
  298.         CRY_ASSERT_MESSAGE(false, "Todo: implement serialization of blocked actions");
  299.         //ser.Value("BlockingActions", m_BlockingActions);
  300.         //ser.Value("BlockedActions", m_BlockedActions);
  301.  
  302.         ser.Value("m_Priority", m_Priority);
  303.         ser.Value("m_Point", m_Point);
  304.         ser.Value("m_SignalText", m_SignalText);
  305.         m_SignalData.Serialize(ser);
  306.         ser.Value("m_Tag", m_Tag);
  307. }
  308.  
  309. //
  310. //----------------------------------------------------------------------------------------------------
  311.  
downloadUnitImg.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