BVB Source Codes

CRYENGINE Show GoalPipe.h Source code

Return Download CRYENGINE: download GoalPipe.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __GOALPIPE_H_
  4. #define __GOALPIPE_H_
  5.  
  6. #if _MSC_VER > 1000
  7.         #pragma once
  8. #endif
  9.  
  10. #include <CryAISystem/IGoalPipe.h>
  11.  
  12. #include <CryAISystem/IAgent.h>
  13. #include "GoalOp.h"
  14.  
  15. #include <vector>
  16.  
  17. // TODO evgeny: What is QGoal?
  18. struct QGoal
  19. {
  20.         // _smart_ptr required only because we keep these in STL vectors
  21.         // if pGoalOp is null, this is goal is actually a subpipe
  22.         _smart_ptr<CGoalOp>   pGoalOp;
  23.         EGoalOperations       op;
  24.         string                sPipeName; // The name of the possible pipe.
  25.         GoalParameters        params;
  26.         bool                  bBlocking;
  27.         IGoalPipe::EGroupType eGrouping;
  28.  
  29.         QGoal() : pGoalOp(0), bBlocking(false), eGrouping(IGoalPipe::eGT_NOGROUP) {}
  30.  
  31.         QGoal Clone();
  32.  
  33.         bool  operator==(const QGoal& other) const
  34.         {
  35.                 return pGoalOp == other.pGoalOp;
  36.         }
  37.  
  38.         void Serialize(TSerialize ser);
  39. };
  40.  
  41. typedef std::vector<QGoal>    VectorOGoals;
  42.  
  43. typedef std::map<string, int> LabelsMap;
  44.  
  45. enum EPopGoalResult
  46. {
  47.         ePGR_AtEnd,
  48.         ePGR_Succeed,
  49.         ePGR_BreakLoop,
  50. };
  51.  
  52. /*! This class defines a logical set of actions that an agent performs in succession.
  53.  */
  54. class CGoalPipe : public IGoalPipe
  55. {
  56. public:
  57.         CGoalPipe(const char* sName, bool bDynamic = false);
  58.         virtual ~CGoalPipe();
  59.  
  60.         CGoalPipe*          Clone();
  61.  
  62.         virtual const char* GetName() const { return m_sName.c_str(); }
  63.         virtual void        HighPriority()  { m_bHighPriority = true; }
  64.  
  65.         virtual void        PushGoal(const XmlNodeRef& goalOpNode, EGroupType eGrouping);
  66.         virtual void        PushGoal(IGoalOp* pGoalOp, EGoalOperations op, bool bBlocking, EGroupType eGrouping, const GoalParameters& params);
  67.         virtual void        PushGoal(EGoalOperations op, bool bBlocking, EGroupType eGrouping, GoalParameters& params);
  68.         virtual void        PushLabel(const char* label);
  69.         virtual void        PushPipe(const char* szName, bool bBlocking, EGroupType eGrouping, GoalParameters& params);
  70.         virtual void        SetDebugName(const char* name);
  71.  
  72.         virtual void        ParseParams(const GoalParams& node);
  73.         virtual void        ParseParam(const char* param, const GoalParams& node);
  74.  
  75.         // Getters/setters
  76.  
  77.         const string&              GetNameAsString() const                        { return m_sName; }
  78.  
  79.         bool                       IsDynamic() const                              { return m_bDynamic; }
  80.  
  81.         int                        GetEventId() const                             { return m_nEventId; }
  82.         void                       SetEventId(int id)                             { m_nEventId = id; }
  83.  
  84.         bool                       IsHighPriority() const                         { return m_bHighPriority; }
  85.  
  86.         const Vec3&                GetAttTargetPosAtStart() const                 { return m_vAttTargetPosAtStart; }
  87.         void                       SetAttTargetPosAtStart(const Vec3& v)          { m_vAttTargetPosAtStart = v; }
  88.  
  89.         const string&              GetDebugName() const                           { return m_sDebugName; }
  90.  
  91.         const CWeakRef<CAIObject>& GetRefArgument() const                         { return m_refArgument; }
  92.         CWeakRef<CAIObject>&       GetRefArgument()                               { return m_refArgument; }
  93.         void                       SetRefArgument(const CWeakRef<CAIObject>& ref) { m_refArgument = ref; }
  94.  
  95.         EGoalOpResult              GetLastResult() const
  96.         {
  97.                 return m_pSubPipe ? m_pSubPipe->GetLastResult() : m_lastResult;
  98.         }
  99.  
  100.         void SetLastResult(EGoalOpResult res)
  101.         {
  102.                 if (m_pSubPipe)
  103.                 {
  104.                         m_pSubPipe->SetLastResult(res);
  105.                 }
  106.                 m_lastResult = res;
  107.         }
  108.  
  109.         int  GetPosition() const { return m_nPosition; }
  110.         void SetPosition(int nPos)
  111.         {
  112.                 if ((0 < nPos) && (static_cast<unsigned int>(nPos) < m_qGoalPipe.size()))
  113.                 {
  114.                         m_nPosition = nPos;
  115.                 }
  116.         }
  117.  
  118.         CGoalPipe*       GetSubpipe()        { return m_pSubPipe; }
  119.         const CGoalPipe* GetSubpipe()  const { return m_pSubPipe; }
  120.         void             SetSubpipe(CGoalPipe* pPipe);
  121.  
  122.         void             SetLoop(bool bLoop) { m_bLoop = bLoop; }
  123.         bool             IsLoop() const      { return m_bLoop; }
  124.  
  125.         uint32           GetNumGoalOps() const
  126.         {
  127.                 return m_qGoalPipe.size();
  128.         }
  129.  
  130.         CGoalOp* GetGoalOp(uint32 index)
  131.         {
  132.                 CGoalOp* ret = 0;
  133.  
  134.                 if (index < m_qGoalPipe.size())
  135.                 {
  136.                         ret = m_qGoalPipe[index].pGoalOp;
  137.                 }
  138.  
  139.                 return ret;
  140.         }
  141.  
  142.         const CGoalOp* GetGoalOp(uint32 index) const
  143.         {
  144.                 CGoalOp* ret = 0;
  145.  
  146.                 if (index < m_qGoalPipe.size())
  147.                 {
  148.                         ret = m_qGoalPipe[index].pGoalOp;
  149.                 }
  150.  
  151.                 return ret;
  152.         }
  153.  
  154.         bool IsGoalBlocking(uint32 index) const
  155.         {
  156.                 //out of bounds goals are not blocking by default
  157.                 return (index < m_qGoalPipe.size() && m_qGoalPipe[index].bBlocking);
  158.         }
  159.  
  160.         //////////////////////////////////////////////////////////////////////////
  161.  
  162.         EPopGoalResult PopGoal(QGoal& theGoal, CPipeUser* pPipeUser);
  163.         EPopGoalResult PeekPopGoalResult() const;
  164.  
  165.         // Makes the IP of this pipe jump to the desired position
  166.         bool Jump(int position);
  167.  
  168.         // TODO: cut the string version of Jump in a few weeks
  169.         bool Jump(const char* label);
  170.  
  171.         // Does Jump(-1) or more to start from the beginning of current group
  172.         void             ReExecuteGroup();
  173.  
  174.         bool             IsInSubpipe() const    { return m_pSubPipe != 0; }
  175.  
  176.         CGoalPipe*       GetLastSubpipe()       { return m_pSubPipe ? m_pSubPipe->GetLastSubpipe() : this; }
  177.         const CGoalPipe* GetLastSubpipe() const { return m_pSubPipe ? m_pSubPipe->GetLastSubpipe() : this; }
  178.  
  179.         int              CountSubpipes() const  { return m_pSubPipe ? (m_pSubPipe->CountSubpipes() + 1) : 0; }
  180.         bool             RemoveSubpipe(CPipeUser* pPipeUser, int& goalPipeId, bool keepInserted, bool keepHigherPriority);
  181.  
  182.         void             Serialize(TSerialize ser, VectorOGoals& activeGoals);
  183. #ifdef SERIALIZE_DYNAMIC_GOALPIPES
  184.         void             SerializeDynamic(TSerialize ser);
  185. #endif // SERIALIZE_DYNAMIC_GOALPIPES
  186.  
  187.         void ResetGoalops(CPipeUser* pPipeUser);
  188.         void Reset();
  189.  
  190.         //////////////////////////////////////////////////////////////////////////
  191.  
  192.         static EGoalOperations GetGoalOpEnum(const char* szName);
  193.         static const char*     GetGoalOpName(EGoalOperations op);
  194.  
  195.         CGoalOp*               CreateGoalOp(EGoalOperations op, const XmlNodeRef& goalOpNode);
  196.  
  197.         size_t                 MemStats();
  198.  
  199.         //////////////////////////////////////////////////////////////////////////
  200.  
  201.         bool m_bKeepOnTop;//TODO make private!
  202.  
  203. private:
  204.         CGoalPipe();
  205.         string m_sName;
  206.  
  207.         // true, if the pipe was created after the initialization of the AI System
  208.         // (including loading of aiconfig.lua);
  209.         // more precisely, after goal pipe "_last_" was created, as of 28.01.2010
  210.         bool m_bDynamic;
  211.  
  212.         int  m_nEventId;
  213.         bool m_bHighPriority;
  214.  
  215.         // position of owner's attention target when pipe is selected OR new target is set
  216.         Vec3                m_vAttTargetPosAtStart;
  217.  
  218.         string              m_sDebugName;
  219.         CWeakRef<CAIObject> m_refArgument;
  220.         EGoalOpResult       m_lastResult;
  221.         VectorOGoals        m_qGoalPipe;
  222.         LabelsMap           m_Labels;
  223.         unsigned int        m_nPosition; // position in pipe
  224.         CGoalPipe*          m_pSubPipe;
  225.         bool                m_bLoop;
  226.  
  227.         //to be used for WAIT goalOp initialization
  228.         int m_nCurrentBlockCounter;
  229. };
  230.  
  231. #endif  // #ifndef __GOALPIPE_H_
  232.  
downloadGoalPipe.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