BVB Source Codes

CRYENGINE Show SequenceFlowNodes.h Source code

Return Download CRYENGINE: download SequenceFlowNodes.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #pragma once
  4.  
  5. #include "SequenceManager.h"
  6. #include <CryFlowGraph/IFlowBaseNode.h>
  7.  
  8. #ifndef _LIB
  9. struct AIFlowBaseNode
  10. {
  11.         static void RegisterFlowNodes();
  12.         static void UnregisterFlowNodes();
  13. };
  14. #endif
  15.  
  16. namespace AIActionSequence
  17. {
  18.  
  19. //////////////////////////////////////////////////////////////////////////
  20.  
  21. struct SequenceFlowNodeBase
  22.         : public CFlowBaseNode<eNCT_Instanced>
  23.           , public SequenceActionBase
  24. {
  25.         // nothing
  26. };
  27.  
  28. //////////////////////////////////////////////////////////////////////////
  29.  
  30. struct GoalPipeListenerHelper
  31. {
  32. public:
  33.         GoalPipeListenerHelper()
  34.                 : m_goalPipeId(0)
  35.         {}
  36.  
  37.         void RegisterGoalPipeListener(IGoalPipeListener* listener, EntityId entityId, int goalPipeId);
  38.         void UnRegisterGoalPipeListener(IGoalPipeListener* listener, EntityId entityId);
  39.  
  40. private:
  41.         int m_goalPipeId;
  42. };
  43.  
  44. //////////////////////////////////////////////////////////////////////////
  45.  
  46. class CFlowNode_AISequenceStart
  47.         : public SequenceFlowNodeBase
  48. {
  49. public:
  50.         enum InputPort
  51.         {
  52.                 InputPort_Start,
  53.                 InputPort_Interruptible,
  54.                 InputPort_ResumeAfterInterruption,
  55.         };
  56.  
  57.         enum OutputPort
  58.         {
  59.                 OutputPort_Link,
  60.         };
  61.  
  62.         CFlowNode_AISequenceStart(SActivationInfo* pActInfo)
  63.                 : m_actInfo(*pActInfo)
  64.                 , m_restartOnPostSerialize(false)
  65.                 , m_waitingForTheForwardingEntityToBeSetOnAllTheNodes(false)
  66.         {
  67.         }
  68.  
  69.         virtual ~CFlowNode_AISequenceStart();
  70.  
  71.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceStart(pActInfo); }
  72.  
  73.         virtual void         Serialize(SActivationInfo* pActInfo, TSerialize ser);
  74.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  75.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  76.         virtual void         PostSerialize(SActivationInfo* pActInfo);
  77.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  78.  
  79.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  80.  
  81. private:
  82.         void InitializeSequence(SActivationInfo* pActInfo);
  83.  
  84.         bool            m_restartOnPostSerialize;
  85.         bool            m_waitingForTheForwardingEntityToBeSetOnAllTheNodes;
  86.         SActivationInfo m_actInfo;
  87. };
  88.  
  89. //////////////////////////////////////////////////////////////////////////
  90.  
  91. class CFlowNode_AISequenceEnd
  92.         : public SequenceFlowNodeBase
  93. {
  94. public:
  95.         enum InputPort
  96.         {
  97.                 InputPort_End,
  98.         };
  99.  
  100.         enum OutputPort
  101.         {
  102.                 OutputPort_Done,
  103.         };
  104.  
  105.         CFlowNode_AISequenceEnd(SActivationInfo* pActInfo) {}
  106.         virtual ~CFlowNode_AISequenceEnd() {}
  107.  
  108.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceEnd(pActInfo); }
  109.  
  110.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  111.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  112.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  113.  
  114. private:
  115. };
  116.  
  117. //////////////////////////////////////////////////////////////////////////
  118.  
  119. class CFlowNode_AISequenceBookmark
  120.         : public SequenceFlowNodeBase
  121. {
  122. public:
  123.         enum InputPort
  124.         {
  125.                 InputPort_Set,
  126.         };
  127.  
  128.         enum OutputPort
  129.         {
  130.                 OutputPort_Link,
  131.         };
  132.  
  133.         CFlowNode_AISequenceBookmark(SActivationInfo* pActInfo)
  134.                 : m_actInfo(*pActInfo)
  135.         {}
  136.  
  137.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceBookmark(pActInfo); }
  138.  
  139.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  140.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  141.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  142.  
  143.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  144.  
  145. private:
  146.         SActivationInfo m_actInfo;
  147. };
  148.  
  149. //////////////////////////////////////////////////////////////////////////
  150.  
  151. class CFlowNode_AISequenceActionMove
  152.         : public SequenceFlowNodeBase
  153.           , public IGoalPipeListener
  154.           , public GoalPipeListenerHelper
  155. {
  156. public:
  157.         enum InputPort
  158.         {
  159.                 InputPort_Start,
  160.                 InputPort_Speed,
  161.                 InputPort_Stance,
  162.                 InputPort_DestinationEntity,
  163.                 InputPort_Position,
  164.                 InputPort_Direction,
  165.                 InputPort_EndDistance,
  166.         };
  167.  
  168.         enum OutputPort
  169.         {
  170.                 OutputPort_Done,
  171.         };
  172.  
  173.         CFlowNode_AISequenceActionMove(SActivationInfo* pActInfo)
  174.                 : m_actInfo(*pActInfo)
  175.         {
  176.         }
  177.         virtual ~CFlowNode_AISequenceActionMove();
  178.  
  179.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceActionMove(pActInfo); }
  180.  
  181.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  182.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  183.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  184.  
  185.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  186.  
  187.         virtual void         OnGoalPipeEvent(IPipeUser* pipeUser, EGoalPipeEvent event, int goalPipeId, bool& unregisterListenerAfterEvent);
  188.  
  189. private:
  190.         void GetPositionAndDirectionForDestination(OUT Vec3& position, OUT Vec3& direction);
  191.  
  192.         SActivationInfo m_actInfo;
  193. };
  194.  
  195. //////////////////////////////////////////////////////////////////////////
  196.  
  197. class CFlowNode_AISequenceActionMoveAlongPath
  198.         : public SequenceFlowNodeBase
  199.           , public IGoalPipeListener
  200.           , public GoalPipeListenerHelper
  201. {
  202. public:
  203.         enum InputPort
  204.         {
  205.                 InputPort_Start,
  206.                 InputPort_Speed,
  207.                 InputPort_Stance,
  208.                 InputPort_PathName,
  209.         };
  210.  
  211.         enum OutputPort
  212.         {
  213.                 OutputPort_Done,
  214.         };
  215.  
  216.         CFlowNode_AISequenceActionMoveAlongPath(SActivationInfo* pActInfo)
  217.                 : m_actInfo(*pActInfo)
  218.         {
  219.         }
  220.         virtual ~CFlowNode_AISequenceActionMoveAlongPath();
  221.  
  222.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceActionMoveAlongPath(pActInfo); }
  223.  
  224.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  225.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  226.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  227.  
  228.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  229.  
  230.         virtual void         OnGoalPipeEvent(IPipeUser* pipeUser, EGoalPipeEvent event, int goalPipeId, bool& unregisterListenerAfterEvent);
  231.  
  232. private:
  233.         void GetTeleportEndPositionAndDirection(const char* pathName, Vec3& position, Vec3& direction);
  234.  
  235.         SActivationInfo m_actInfo;
  236. };
  237.  
  238. //////////////////////////////////////////////////////////////////////////
  239.  
  240. class CFlowNode_AISequenceActionAnimation
  241.         : public SequenceFlowNodeBase
  242.           , public IGoalPipeListener
  243.           , public GoalPipeListenerHelper
  244. {
  245. public:
  246.         enum InputPort
  247.         {
  248.                 InputPort_Start,
  249.                 InputPort_Stop,
  250.                 InputPort_Animation,
  251.                 InputPort_DestinationEntity,
  252.                 InputPort_Position,
  253.                 InputPort_Direction,
  254.                 InputPort_Speed,
  255.                 InputPort_Stance,
  256.                 InputPort_OneShot,
  257.                 InputPort_StartRadius,
  258.                 InputPort_DirectionTolerance,
  259.                 InputPort_LoopDuration,
  260.         };
  261.  
  262.         enum OutputPort
  263.         {
  264.                 OutputPort_Done,
  265.         };
  266.  
  267.         CFlowNode_AISequenceActionAnimation(SActivationInfo* pActInfo)
  268.                 : m_actInfo(*pActInfo)
  269.                 , m_running(false)
  270.         {
  271.         }
  272.         virtual ~CFlowNode_AISequenceActionAnimation();
  273.  
  274.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceActionAnimation(pActInfo); }
  275.  
  276.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  277.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  278.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  279.  
  280.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  281.         virtual void         OnGoalPipeEvent(IPipeUser* pipeUser, EGoalPipeEvent event, int goalPipeId, bool& unregisterListenerAfterEvent);
  282.  
  283. private:
  284.         void       GetPositionAndDirectionForDestination(Vec3& position, Vec3& direction);
  285.         void       ClearAnimation(bool bHurry);
  286.         IAIObject* GetAssignedEntityAIObject();
  287.  
  288.         SActivationInfo m_actInfo;
  289.         bool            m_running;
  290. };
  291.  
  292. //////////////////////////////////////////////////////////////////////////
  293.  
  294. class CFlowNode_AISequenceActionWait
  295.         : public SequenceFlowNodeBase
  296.           , public IGoalPipeListener
  297.           , public GoalPipeListenerHelper
  298. {
  299. public:
  300.         enum InputPort
  301.         {
  302.                 InputPort_Start,
  303.                 InputPort_Time,
  304.         };
  305.  
  306.         enum OutputPort
  307.         {
  308.                 OutputPort_Done,
  309.         };
  310.  
  311.         CFlowNode_AISequenceActionWait(SActivationInfo* pActInfo)
  312.                 : m_actInfo(*pActInfo)
  313.         {}
  314.  
  315.         virtual ~CFlowNode_AISequenceActionWait();
  316.  
  317.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceActionWait(pActInfo); }
  318.  
  319.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  320.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  321.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  322.  
  323.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  324.  
  325.         virtual void         OnGoalPipeEvent(IPipeUser* pipeUser, EGoalPipeEvent event, int goalPipeId, bool& unregisterListenerAfterEvent);
  326.  
  327. private:
  328.         SActivationInfo m_actInfo;
  329. };
  330.  
  331. //////////////////////////////////////////////////////////////////////////
  332.  
  333. class CFlowNode_AISequenceActionShoot
  334.         : public SequenceFlowNodeBase
  335.           , public IGoalPipeListener
  336.           , public GoalPipeListenerHelper
  337. {
  338. public:
  339.         enum InputPort
  340.         {
  341.                 InputPort_Start,
  342.                 InputPort_TargetEntity,
  343.                 InputPort_TargetPosition,
  344.                 InputPort_Duration,
  345.         };
  346.  
  347.         enum OutputPort
  348.         {
  349.                 OutputPort_Done,
  350.         };
  351.  
  352.         CFlowNode_AISequenceActionShoot(SActivationInfo* pActInfo)
  353.                 : m_actInfo(*pActInfo)
  354.         {
  355.         }
  356.  
  357.         virtual ~CFlowNode_AISequenceActionShoot();
  358.  
  359.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceActionShoot(pActInfo); }
  360.  
  361.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  362.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  363.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  364.  
  365.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  366.  
  367.         virtual void         OnGoalPipeEvent(IPipeUser* pipeUser, EGoalPipeEvent event, int goalPipeId, bool& unregisterListenerAfterEvent);
  368.  
  369. private:
  370.         SActivationInfo m_actInfo;
  371. };
  372.  
  373. //////////////////////////////////////////////////////////////////////////
  374.  
  375. class CFlowNode_AISequenceHoldFormation
  376.         : public SequenceFlowNodeBase
  377. {
  378. public:
  379.         enum InputPort
  380.         {
  381.                 InputPort_Start,
  382.                 InputPort_FormationName,
  383.         };
  384.  
  385.         enum OutputPort
  386.         {
  387.                 OutputPort_Done,
  388.         };
  389.  
  390.         CFlowNode_AISequenceHoldFormation(SActivationInfo* pActInfo)
  391.                 : m_actInfo(*pActInfo)
  392.         {
  393.         }
  394.  
  395.         virtual ~CFlowNode_AISequenceHoldFormation() {}
  396.  
  397.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceHoldFormation(pActInfo); }
  398.  
  399.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  400.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  401.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  402.  
  403. private:
  404.         SActivationInfo m_actInfo;
  405. };
  406.  
  407. class CFlowNode_AISequenceJoinFormation
  408.         : public SequenceFlowNodeBase
  409. {
  410. public:
  411.         enum InputPort
  412.         {
  413.                 InputPort_Start,
  414.                 InputPort_LeaderId,
  415.         };
  416.  
  417.         enum OutputPort
  418.         {
  419.                 OutputPort_Done,
  420.         };
  421.  
  422.         CFlowNode_AISequenceJoinFormation(SActivationInfo* pActInfo)
  423.                 : m_actInfo(*pActInfo)
  424.         {
  425.         }
  426.  
  427.         virtual ~CFlowNode_AISequenceJoinFormation() {}
  428.  
  429.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceJoinFormation(pActInfo); }
  430.  
  431.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  432.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  433.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  434.  
  435. private:
  436.  
  437.         void SendSignal(IAIActor* pIAIActor, const char* signalName, IEntity* pSender);
  438.  
  439.         SActivationInfo m_actInfo;
  440. };
  441.  
  442. //////////////////////////////////////////////////////////////////////////
  443.  
  444. class CFlowNode_AISequenceAction_Stance
  445.         : public SequenceFlowNodeBase
  446. {
  447. public:
  448.         enum InputPort
  449.         {
  450.                 InputPort_Start,
  451.                 InputPort_Stance,
  452.         };
  453.  
  454.         enum OutputPort
  455.         {
  456.                 OutputPort_Done,
  457.         };
  458.  
  459.         CFlowNode_AISequenceAction_Stance(SActivationInfo* pActInfo)
  460.                 : m_actInfo(*pActInfo)
  461.         {
  462.         }
  463.  
  464.         virtual ~CFlowNode_AISequenceAction_Stance() {}
  465.  
  466.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) { return new CFlowNode_AISequenceAction_Stance(pActInfo); }
  467.  
  468.         virtual void         GetConfiguration(SFlowNodeConfig& config);
  469.         virtual void         ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo);
  470.         virtual void         GetMemoryUsage(ICrySizer* sizer) const { sizer->Add(*this); }
  471.  
  472.         void                 HandleSequenceEvent(SequenceEvent sequenceEvent);
  473.  
  474. private:
  475.         SActivationInfo m_actInfo;
  476. };
  477.  
  478. //////////////////////////////////////////////////////////////////////////
  479.  
  480. } // namespace AIActionSequence
  481.  
downloadSequenceFlowNodes.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