BVB Source Codes

CRYENGINE Show LeaderAction.h Source code

Return Download CRYENGINE: download LeaderAction.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   LeaderAction.h
  6.  
  7.    Description: Header for CLeaderAction, CUnitImg, classes
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 15:11:2004   17:41 : Created by Luciano Morpurgo
  12.  
  13.  *********************************************************************/
  14.  
  15. #ifndef __LeaderAction_H__
  16. #define __LeaderAction_H__
  17.  
  18. #if _MSC_VER > 1000
  19.         #pragma once
  20. #endif
  21.  
  22. #include <CryAISystem/IAgent.h>
  23. #include <CryAISystem/AIFormationDescriptor.h>
  24. #include "AIObject.h"
  25. #include "Graph.h"
  26. #include "UnitAction.h"
  27. #include "UnitImg.h"
  28. #include <CrySystem/TimeValue.h>
  29. #include <CryMath/Cry_Math.h>
  30. #include <list>
  31.  
  32. class CLeader;
  33.  
  34. enum  ELeaderActionSubType
  35. {
  36.         LAS_DEFAULT = 0,
  37.         LAS_ATTACK_ROW,
  38.         LAS_ATTACK_CIRCLE,
  39.         LAS_ATTACK_FLANK,
  40.         LAS_ATTACK_FLANK_HIDE,
  41.         LAS_ATTACK_FOLLOW_LEADER,
  42.         LAS_ATTACK_FUNNEL,
  43.         LAS_ATTACK_LEAPFROG,
  44.         LAS_ATTACK_HIDE_COVER,
  45.         LAS_ATTACK_FRONT,
  46.         LAS_ATTACK_CHAIN,
  47.         LAS_ATTACK_COORDINATED_FIRE1,
  48.         LAS_ATTACK_COORDINATED_FIRE2,
  49.         LAS_ATTACK_USE_SPOTS,
  50.         LAS_ATTACK_HIDE,
  51.         LAS_ATTACK_SWITCH_POSITIONS,
  52.         LAS_ATTACK_CHASE,
  53.         LAS_SEARCH_DEFAULT,
  54.         LAS_SEARCH_COVER,
  55.         LAS_LAST  // Make sure this one is always the last!
  56. };
  57.  
  58. struct LeaderActionParams
  59. {
  60.         ELeaderAction        type;
  61.         ELeaderActionSubType subType;
  62.         float                fDuration;
  63.         string               name;
  64.         Vec3                 vPoint;
  65.         Vec3                 vPoint2;
  66.         float                fSize;
  67.         int                  iValue;
  68.         uint32               unitProperties;
  69.         CAIObject*           pAIObject;
  70.         ScriptHandle         id;
  71.  
  72.         LeaderActionParams(ELeaderAction t, ELeaderActionSubType s) : type(t), subType(s), fDuration(0), vPoint(ZERO), fSize(0), vPoint2(ZERO), pAIObject(NULL), iValue(0)  {};
  73.         LeaderActionParams() : type(LA_LAST), subType(LAS_DEFAULT), fDuration(0), vPoint(ZERO), fSize(0), vPoint2(ZERO), pAIObject(NULL), iValue(0) {};
  74.  
  75. };
  76.  
  77. class CLeaderAction
  78. {
  79. protected:
  80.         typedef std::list<std::pair<CUnitImg*, CUnitAction*>> ActionList;
  81.         struct BlockActionList
  82.         {
  83.                 BlockActionList(ActionList& blockers, ActionList& blocked)
  84.                 {
  85.                         ActionList::iterator i, j, iEnd = blockers.end(), jEnd = blocked.end();
  86.                         for (i = blockers.begin(); i != iEnd; ++i)
  87.                                 for (j = blocked.begin(); j != jEnd; ++j)
  88.                                         j->second->BlockedBy(i->second);
  89.                 }
  90.         };
  91.         struct PushPlanFromList
  92.         {
  93.                 static void Do(ActionList& actionList)
  94.                 {
  95.                         ActionList::iterator it, itEnd = actionList.end();
  96.                         for (it = actionList.begin(); it != itEnd; ++it)
  97.                                 it->first->m_Plan.push_back(it->second);
  98.                 }
  99.         };
  100.  
  101. public:
  102.         typedef enum
  103.         {
  104.                 ACTION_RUNNING,
  105.                 ACTION_DONE,
  106.                 ACTION_FAILED
  107.         } eActionUpdateResult;
  108.  
  109.         CLeaderAction();
  110.         CLeaderAction(CLeader* pLeader);
  111.         virtual ~CLeaderAction();
  112.  
  113.         ELeaderAction               GetType() const           { return m_eActionType; };
  114.         ELeaderActionSubType        GetSubType() const        { return m_eActionSubType; };
  115.         int                         GetNumLiveUnits() const;
  116.         inline uint32               GetUnitProperties() const { return m_unitProperties; }
  117.  
  118.         bool                        IsUnitAvailable(const CUnitImg& unit) const;
  119.  
  120.         virtual eActionUpdateResult Update() { return ACTION_DONE; }
  121.         virtual void                DeadUnitNotify(CAIActor* pObj); // CLeaderAction will manage the inter-dependencies between
  122.         // the died member's actions and other members ones
  123.         virtual void                BusyUnitNotify(CUnitImg&); // CLeaderAction will manage the inter-dependencies between
  124.         // the busy member's actions and other members ones
  125.         virtual void                ResumeUnit(CUnitImg&)                 {}; // CLeaderAction will re-create a planning for the resumed unit
  126.         virtual bool                ProcessSignal(const AISIGNAL& signal) { return false; }
  127.         inline void                 SetPriority(int priority)             { m_Priority = priority; };
  128.         inline int                  GetPriority() const                   { return m_Priority; };
  129.  
  130.         TUnitList&   GetUnitsList() const;
  131.         virtual void Serialize(TSerialize ser);
  132.  
  133.         virtual void SetUnitFollow(CUnitImg& unit)                         {};
  134.         virtual void SetUnitHold(CUnitImg& unit, const Vec3& point = ZERO) {};
  135.         virtual void UpdateBeacon() const;
  136.         // Returns pointer to the unit image of the group formation.
  137.         CUnitImg*    GetFormationOwnerImg() const;
  138.         virtual void AddUnitNotify(CAIActor* pUnit) {};
  139.  
  140. protected:
  141.         CLeader*                   m_pLeader;
  142.         ELeaderAction              m_eActionType;
  143.         ELeaderActionSubType       m_eActionSubType;
  144.         int                        m_Priority;
  145.         uint32                     m_unitProperties;
  146.         IAISystem::ENavigationType m_currentNavType;
  147.         IAISystem::tNavCapMask     m_NavProperties;
  148.  
  149. protected:
  150.         void        CheckLeaderDistance() const;
  151.         const Vec3& GetDestinationPoint();
  152.         bool        IsUnitTooFar(const CUnitImg& tUnit, const Vec3& vPos) const;
  153.         void        CheckNavType(CAIActor* pMember, bool bSignal);
  154.         void        SetTeamNavProperties();
  155.         void        ClearUnitFlags();
  156.  
  157.         //////////////////////////////////////////////////////////////////////////
  158. };
  159.  
  160. class CLeaderAction_Attack : public CLeaderAction
  161. {
  162. public:
  163.         CLeaderAction_Attack(CLeader* pLeader);
  164.         CLeaderAction_Attack();//used for derived classes' constructors
  165.         virtual ~CLeaderAction_Attack();
  166.  
  167.         virtual bool ProcessSignal(const AISIGNAL& signal);
  168.         virtual void Serialize(TSerialize ser);
  169. protected:
  170.         bool         HasTarget(CAIObject* unit) const;
  171.         bool               m_bInitialized;
  172.         bool               m_bStealth;
  173.         bool               m_bApproachWithNoObstacle;
  174.         bool               m_bNoTarget;
  175.         CTimeValue         m_timeRunning;
  176.         float              m_timeLimit;
  177.         static const float m_CSearchDistance;
  178.         Vec3               m_vDefensePoint;
  179.         Vec3               m_vEnemyPos;
  180.  
  181. };
  182.  
  183. typedef std::list<CObstacleRef> ListObstacleRefs;
  184.  
  185. class CLeaderAction_Search : public CLeaderAction
  186. {
  187. public:
  188.         struct SSearchPoint
  189.         {
  190.                 Vec3 pos;
  191.                 Vec3 dir;
  192.                 bool bReserved;
  193.                 bool bHideSpot;
  194.                 SSearchPoint() { bReserved = false; bHideSpot = false; }
  195.                 SSearchPoint(const Vec3& p, const Vec3& d) : pos(p), dir(d) { bReserved = false; bHideSpot = false; }
  196.                 SSearchPoint(const Vec3& p, const Vec3& d, bool hideSpot) : pos(p), dir(d) { bReserved = false; bHideSpot = hideSpot; }
  197.                 virtual ~SSearchPoint(){}
  198.                 virtual void Serialize(TSerialize ser)
  199.                 {
  200.                         ser.Value("pos", pos);
  201.                         ser.Value("dir", dir);
  202.                         ser.Value("bReserved", bReserved);
  203.                         ser.Value("bHideSpot", bHideSpot);
  204.                 }
  205.  
  206.         };
  207.         typedef std::multimap<float, SSearchPoint> TPointMap;
  208.         CLeaderAction_Search(CLeader* pLeader, const LeaderActionParams& params);
  209.         virtual ~CLeaderAction_Search();
  210.  
  211.         virtual eActionUpdateResult Update();
  212.  
  213.         virtual bool                ProcessSignal(const AISIGNAL& signal);
  214.         virtual void                Serialize(TSerialize ser);
  215. private:
  216.         void                        PopulateSearchSpotList(Vec3& initPos);
  217.  
  218.         CTimeValue          m_timeRunning;
  219.         enum  { m_timeLimit = 20 };
  220.         static const float  m_CSearchDistance;
  221.         static const uint32 m_CCoverUnitProperties;
  222.         int                 m_iCoverUnitsLeft;
  223.         Vec3                m_vEnemyPos;
  224.         float               m_fSearchDistance;
  225.         //SetObstacleRefs               m_Passed;
  226.         //ListObstacleRefs      m_Obstacles;
  227.         TPointMap m_HideSpots;
  228.         bool      m_bInitialized;
  229.         int       m_iSearchSpotAIObjectType;
  230.         bool      m_bUseHideSpots;
  231.         CAIActor* pSelectedUnit;
  232.  
  233. };
  234.  
  235. //----------------------------------------------------------
  236. class CLeaderAction_Attack_SwitchPositions : public CLeaderAction_Attack
  237. {
  238. public:
  239.  
  240.         CLeaderAction_Attack_SwitchPositions(CLeader* pLeader, const LeaderActionParams& params);
  241.         CLeaderAction_Attack_SwitchPositions(); //used for derived classes' constructors
  242.  
  243.         virtual ~CLeaderAction_Attack_SwitchPositions();
  244.         virtual eActionUpdateResult Update();
  245.         virtual void                Serialize(TSerialize ser);
  246.         bool                        ProcessSignal(const AISIGNAL& signal);
  247.         virtual void                OnObjectRemoved(CAIObject* pObject);
  248.         virtual void                AddUnitNotify(CAIActor* pUnit);
  249.         void                        UpdateBeaconWithTarget(const CAIObject* pTarget = NULL) const;
  250.  
  251. protected:
  252.         struct SDangerPoint
  253.         {
  254.                 virtual ~SDangerPoint(){}
  255.  
  256.                 SDangerPoint()
  257.                         : time(.0f)
  258.                         , radius(.0f)
  259.                         , point(ZERO)
  260.                 {}
  261.  
  262.                 SDangerPoint(float t, float r, Vec3& p)
  263.                 {
  264.                         time = t;
  265.                         radius = r;
  266.                         point = p;
  267.                 };
  268.  
  269.                 virtual void Serialize(TSerialize ser)
  270.                 {
  271.                         ser.Value("time", time);
  272.                         ser.Value("radius", radius);
  273.                         ser.Value("point", point);
  274.                 }
  275.                 float time;
  276.                 float radius;
  277.                 Vec3  point;
  278.         };
  279.         struct STargetData
  280.         {
  281.                 virtual ~STargetData(){}
  282.                 CWeakRef<CAIObject>        refTarget;
  283.                 IAISystem::ENavigationType navType;
  284.                 IAISystem::ENavigationType targetNavType;
  285.                 STargetData() : navType(IAISystem::NAV_UNSET), targetNavType(IAISystem::NAV_UNSET) {}
  286.  
  287.                 virtual void Serialize(TSerialize ser)
  288.                 {
  289.                         ser.EnumValue("navType", navType, IAISystem::NAV_UNSET, IAISystem::NAV_MAX_VALUE);
  290.                         ser.EnumValue("targetNavType", targetNavType, IAISystem::NAV_UNSET, IAISystem::NAV_MAX_VALUE);
  291.                         refTarget.Serialize(ser, "refTarget");
  292.                 }
  293.         };
  294.  
  295.         typedef enum
  296.         {
  297.                 AS_OFF,
  298.                 AS_WAITING_CONFIRM,
  299.                 AS_ON
  300.         } eActionStatus;
  301.  
  302.         struct SSpecialAction
  303.         {
  304.                 virtual ~SSpecialAction(){}
  305.                 eActionStatus      status;
  306.                 CWeakRef<CAIActor> refOwner;
  307.                 CTimeValue         lastTime;
  308.  
  309.                 SSpecialAction()
  310.                 {
  311.                         status = AS_OFF;
  312.                         lastTime.SetValue(0);
  313.                 }
  314.  
  315.                 SSpecialAction(CWeakRef<CAIActor> _refOwner)
  316.                         : refOwner(_refOwner)
  317.                 {
  318.                         status = AS_OFF;
  319.                         lastTime.SetValue(0);
  320.                 }
  321.  
  322.                 virtual void Serialize(TSerialize ser)
  323.                 {
  324.                         refOwner.Serialize(ser, "refOwner");
  325.                         ser.Value("lastTime", lastTime);
  326.                         ser.EnumValue("status", status, AS_OFF, AS_ON);
  327.                 }
  328.  
  329.         };
  330.  
  331.         struct SPointProperties
  332.         {
  333.                 virtual ~SPointProperties(){}
  334.                 SPointProperties()
  335.                 {
  336.                         bTargetVisible = false;
  337.                         fAngle = 0.f;
  338.                         fValue = 0.f;
  339.                         point.Set(0, 0, 0);
  340.                 }
  341.  
  342.                 SPointProperties(Vec3& p) : point(p)
  343.                 {
  344.                         bTargetVisible = false;
  345.                         fAngle = 0.f;
  346.                         fValue = 0.f;
  347.                 }
  348.  
  349.                 virtual void Serialize(TSerialize ser)
  350.                 {
  351.                         ser.Value("bTargetVisible", bTargetVisible);
  352.                         ser.Value("fAngle", fAngle);
  353.                         ser.Value("fValue", fValue);
  354.                         ser.Value("point", point);
  355.                         refOwner.Serialize(ser, "refOwner");
  356.                 }
  357.  
  358.                 bool                bTargetVisible;
  359.                 float               fAngle;
  360.                 float               fValue;
  361.                 Vec3                point;
  362.                 CWeakRef<CAIObject> refOwner;
  363.  
  364.         };
  365.  
  366.         class CActorSpotListManager
  367.         {
  368.                 typedef std::multimap<const CWeakRef<CAIActor>, Vec3> TActorSpotList;
  369.  
  370.                 TActorSpotList m_ActorSpotList;
  371.         public:
  372.                 virtual ~CActorSpotListManager(){}
  373.                 void AddSpot(const CWeakRef<CAIActor>& refActor, Vec3& point)
  374.                 {
  375.                         m_ActorSpotList.insert(std::make_pair(refActor, point));
  376.                 }
  377.  
  378.                 void RemoveAllSpots(const CWeakRef<CAIActor>& refActor)
  379.                 {
  380.                         m_ActorSpotList.erase(refActor);
  381.                 }
  382.  
  383.                 bool IsForbiddenSpot(const CWeakRef<CAIActor>& refActor, Vec3& point)
  384.                 {
  385.                         TActorSpotList::iterator it = m_ActorSpotList.find(refActor), itEnd = m_ActorSpotList.end();
  386.                         while (it != itEnd && it->first == refActor)
  387.                         {
  388.                                 if (Distance::Point_PointSq(it->second, point) < 1.f)
  389.                                         return true;
  390.  
  391.                                 ++it;
  392.                         }
  393.                         return false;
  394.                 }
  395.  
  396.                 virtual void Serialize(TSerialize ser)
  397.                 {
  398.                         ser.BeginGroup("ActorSpotList");
  399.                         int size = m_ActorSpotList.size();
  400.                         ser.Value("size", size);
  401.                         TActorSpotList::iterator it = m_ActorSpotList.begin();
  402.                         if (ser.IsReading())
  403.                                 m_ActorSpotList.clear();
  404.  
  405.                         Vec3 point;
  406.                         CWeakRef<CAIActor> refUnitActor;
  407.                         char name[32];
  408.  
  409.                         for (int i = 0; i < size; i++)
  410.                         {
  411.                                 cry_sprintf(name, "ActorSpot_%d", i);
  412.                                 ser.BeginGroup(name);
  413.                                 {
  414.                                         if (ser.IsWriting())
  415.                                         {
  416.                                                 refUnitActor = it->first;
  417.                                                 point = it->second;
  418.                                                 ++it;
  419.                                         }
  420.                                         refUnitActor.Serialize(ser, "refUnitActor");
  421.                                         ser.Value("point", point);
  422.  
  423.                                         if (ser.IsReading())
  424.                                                 m_ActorSpotList.insert(std::make_pair(refUnitActor, point));
  425.                                 }
  426.                                 ser.EndGroup();
  427.  
  428.                         }
  429.                         ser.EndGroup();
  430.  
  431.                 }
  432.         };
  433.  
  434.         typedef std::vector<Vec3>                                       TShootSpotList;
  435.         typedef std::vector<SDangerPoint>                               TDangerPointList;
  436.         typedef std::map<CWeakRef<CAIActor>, STargetData>               TMapTargetData; // deprecated
  437.         typedef std::vector<SPointProperties>                           TPointPropertiesList;
  438.  
  439.         typedef std::multimap<CWeakRef<const CAIActor>, SSpecialAction> TSpecialActionMap;
  440.  
  441.         int          GetFormationPointWithTarget(CUnitImg& unit);
  442.         void         InitPointProperties();
  443.         void         CheckNavType(CUnitImg& unit);
  444.         void         InitNavTypeData();
  445.         STargetData* GetTargetData(CUnitImg& unit);
  446.         void         AssignNewShootSpot(CAIObject* pUnit, int i);
  447.         void         UpdatePointList(CAIObject* pTarget = NULL);
  448.         bool         UpdateFormationScale(CFormation* pFormation);
  449.         void         SetFormationSize(const CFormation* pFormation);
  450.         Vec3         GetBaseDirection(CAIObject* pTarget, bool bUseTargetMoveDir = false);
  451.         void         GetBaseSearchPosition(CUnitImg& unit, CAIObject* pTarget, int method, float distance = 0);
  452.         void         UpdateSpecialActions();
  453.         bool         IsVehicle(const CAIActor* pTarget, IEntity** ppVehicleEntity = NULL) const;
  454.         bool         IsSpecialActionConsidered(const CAIActor* pUnit, const CAIActor* pUnitLiveTarget) const;
  455. protected:
  456.  
  457.         TMapTargetData        m_TargetData;
  458.         TSpecialActionMap     m_SpecialActions;
  459.         float                 m_fDistanceToTarget;
  460.         float                 m_fMinDistanceToTarget;
  461.  
  462.         string                m_sFormationType;
  463.         TPointPropertiesList  m_PointProperties;
  464.         bool                  m_bVisibilityChecked;
  465.         bool                  m_bPointsAssigned;
  466.         bool                  m_bAvoidDanger;
  467.         float                 m_fMinDistanceToNextPoint;
  468.         static const float    m_fDefaultMinDistance;
  469.         TDangerPointList      m_DangerPoints;
  470.         Vec3                  m_vUpdatePointTarget;
  471.         float                 m_fFormationSize;
  472.         float                 m_fFormationScale;
  473.         CTimeValue            m_lastScaleUpdateTime;
  474.  
  475.         IAIObject*            m_pLiveTarget; // no need to be serialized, it's initialized at each update
  476.  
  477.         CActorSpotListManager m_ActorForbiddenSpotManager;
  478. };
  479.  
  480. #endif // __LeaderAction_H__
  481.  
downloadLeaderAction.h 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