BVB Source Codes

CRYENGINE Show GoalOp.h Source code

Return Download CRYENGINE: download GoalOp.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __GOALOP_H_
  4. #define __GOALOP_H_
  5.  
  6. #if _MSC_VER > 1000
  7.         #pragma once
  8. #endif
  9.  
  10. #include "AIPIDController.h"
  11. #include <CryMath/Random.h>
  12. #include <CryAISystem/ITacticalPointSystem.h>
  13. #include <CrySystem/TimeValue.h>
  14. #include <CrySystem/XML/XMLAttrReader.h>
  15.  
  16. class CAIObject;
  17. class CPipeUser;
  18. class CPuppet;
  19. struct GraphNode;
  20.  
  21. class COPPathFind;
  22. class COPTrace;
  23.  
  24. enum
  25. {
  26.         AI_LOOKAT_CONTINUOUS  = 1 << 0,
  27.         AI_LOOKAT_USE_BODYDIR = 1 << 1,
  28. };
  29.  
  30. enum EAIRegister
  31. {
  32.         AI_REG_NONE,
  33.         AI_REG_LASTOP,
  34.         AI_REG_REFPOINT,
  35.         AI_REG_ATTENTIONTARGET,
  36.         AI_REG_COVER,
  37.         AI_REG_PATH,
  38.         AI_REG_LAST
  39. };
  40.  
  41. enum ELookMotivation
  42. {
  43.         AILOOKMOTIVATION_LOOK = 0,
  44.         AILOOKMOTIVATION_GLANCE,
  45.         AILOOKMOTIVATION_STARTLE,
  46.         AILOOKMOTIVATION_DOUBLETAKE,
  47. };
  48.  
  49. #if CRY_PLATFORM_APPLE
  50. // WAIT_ANY is defined as (-1) in sys/wait.h
  51.         #undef WAIT_ANY
  52. #endif // CRY_PLATFORM_APPLE
  53.  
  54. enum EOPWaitType
  55. {
  56.         WAIT_ALL   = 0, // Wait for all group to be finished.
  57.         WAIT_ANY   = 1, // Wait for any goal in the group to be finished.
  58.         WAIT_ANY_2 = 2, // Wait for any goal in the group to be finished.
  59.         WAIT_LAST
  60. };
  61.  
  62. enum EOPBranchType
  63. {
  64.         IF_ACTIVE_GOALS = 0,                // Default as it was in CryEngine1 - jumps if there are active (not finished) goal operations.
  65.         IF_ACTIVE_GOALS_HIDE,               // Default as it was in CryEngine1 - jumps if there are active goals or hide spot wasn't found.
  66.         IF_NO_PATH,                         // Jumps if there wasn't a path in the last "pathfind" goal operation.
  67.         IF_PATH_STILL_FINDING,              // Jumps if the current pathfind request hasn't been completed yet.
  68.         IF_IS_HIDDEN,                       // Jumps if the last "hide" goal operation has succeed and distance to hide point is small.
  69.         IF_CAN_HIDE,                        // Jumps if the last "hide" goal operation has succeed.
  70.         IF_CANNOT_HIDE,                     // Jumps if the last "hide" goal operation has failed.
  71.         IF_STANCE_IS,                       // Jumps if the stance of this PipeUser is equal to value specified as 5-th argument.
  72.         IF_FIRE_IS,                         // Jumps if the argument of the last "firecmd" on this PipeUser is equal to 5-th argument.
  73.         IF_HAS_FIRED,                       // Jumps if the PipeUser just fired - fire flag passed to actor.
  74.         IF_NO_LASTOP,                       // Jumps if m_pLastOpResult is NULL (for example if "locate" goalOp returned NULL).
  75.         IF_SEES_LASTOP,                     // Jumps if m_pLastOpResult is visible from here.
  76.         IF_SEES_TARGET,                     // Jumps if attention target is visible from here.
  77.         IF_CAN_SHOOT_TARGET,                // Jumps if nothing between weapon and attention target (can shoot).
  78.         IF_CAN_MELEE,                       // If current weapon has melee fire mode.
  79.         IF_NO_ENEMY_TARGET,                 // Jumps if it hasn't got an enemy attention target.
  80.         IF_PATH_LONGER,                     // Jumps if current path is longer than 5-th argument.
  81.         IF_PATH_SHORTER,                    // Jumps if current path is shorter than 5-th argument.
  82.         IF_PATH_LONGER_RELATIVE,            // Jumps if current path is longer than (5-th argument) times the distance to requested destination.
  83.         IF_NAV_WAYPOINT_HUMAN,              // Jumps if the current navigation graph is waypoint (use for checking indoor).
  84.         IF_NAV_TRIANGULAR,                  // Jumps if the current navigation graph is triangular (use for checking outdoor).
  85.         IF_TARGET_DIST_LESS,                // Jumps if the distance to target is less.
  86.         IF_TARGET_DIST_LESS_ALONG_PATH,     // Jumps if the distance along path to target is less.
  87.         IF_TARGET_DIST_GREATER,             // Jumps if the distance to target is more.
  88.         IF_TARGET_IN_RANGE,                 // Jumps if the distance to target is less than the attackRannge.
  89.         IF_TARGET_OUT_OF_RANGE,             // Jumps if the distance to target is more than the attackRannge.
  90.         IF_TARGET_TO_REFPOINT_DIST_LESS,    // Jumps if the distance between target and refpoint is less.
  91.         IF_TARGET_TO_REFPOINT_DIST_GREATER, // Jumps if the distance between target and refpoint is more.
  92.         IF_TARGET_LOST_TIME_MORE,           // Jumps if target lost time is more.
  93.         IF_TARGET_LOST_TIME_LESS,           // Jumps if target lost time is less.
  94.         IF_LASTOP_DIST_LESS,                // Jumps if the distance to last op result is less.
  95.         IF_LASTOP_DIST_LESS_ALONG_PATH,     // Jumps if the distance to last op result along path is less.
  96.         IF_TARGET_MOVED_SINCE_START,        // Jumps if the distance between current targetPos and targetPos when pipe started more than threshold.
  97.         IF_TARGET_MOVED,                    // Jumps if the distance between current targetPos and targetPos when pipe started (or last time it was checked) more than threshold.
  98.         IF_EXPOSED_TO_TARGET,               // Jumps if the upper torso of the agent is visible towards the target.
  99.         IF_COVER_COMPROMISED,               // Jumps if the current cover cannot be used for hiding or if the hide spots does not exists.
  100.         IF_COVER_NOT_COMPROMISED,           // Negated version of IF_COVER_COMPROMISED.
  101.         IF_COVER_SOFT,                      // If current cover is soft cover.
  102.         IF_COVER_NOT_SOFT,                  // If current cover is not soft cover.
  103.         IF_CAN_SHOOT_TARGET_PRONED,
  104.         IF_CAN_SHOOT_TARGET_CROUCHED,
  105.         IF_CAN_SHOOT_TARGET_STANDING,
  106.         IF_COVER_FIRE_ENABLED,        // If cover fire is not enabled .
  107.         IF_RANDOM,
  108.         IF_LASTOP_FAILED,
  109.         IF_LASTOP_SUCCEED,
  110.         BRANCH_ALWAYS,            // Unconditional jump.
  111.         NOT = 0x100
  112. };
  113.  
  114. enum ECoverUsageLocation
  115. {
  116.         eCUL_None,
  117.         eCUL_Automatic,
  118.         eCUL_Left,
  119.         eCUL_Right,
  120.         eCUL_Center,
  121. };
  122.  
  123. enum ETraceEndMode
  124. {
  125.         eTEM_FixedDistance,
  126.         eTEM_MinimumDistance
  127. };
  128.  
  129. ILINE const char* GetNameSafe(CAIObject* pObject)
  130. {
  131.         return pObject ? pObject->GetName() : "<Null Object>";
  132. }
  133.  
  134. inline int MovementUrgencyToIndex(float urgency)
  135. {
  136.         int sign = urgency < 0.0f ? -1 : 1;
  137.         if (urgency < 0) urgency = -urgency;
  138.  
  139.         if (urgency < (AISPEED_ZERO + AISPEED_SLOW) / 2)
  140.                 return 0;
  141.         else if (urgency < (AISPEED_SLOW + AISPEED_WALK) / 2)
  142.                 return 1 * sign;  // slow
  143.         else if (urgency < (AISPEED_WALK + AISPEED_RUN) / 2)
  144.                 return 2 * sign;  // walk
  145.         else if (urgency < (AISPEED_RUN + AISPEED_SPRINT) / 2)
  146.                 return 3 * sign;  // run
  147.         else
  148.                 return 4 * sign;  // sprint
  149. }
  150.  
  151. class CGoalOpXMLReader
  152. {
  153.         CXMLAttrReader<unsigned short int>  m_dictAIObjectType;
  154.         CXMLAttrReader<EAnimationMode>      m_dictAnimationMode;
  155.         CXMLAttrReader<bool>                m_dictBools;
  156.         CXMLAttrReader<ECoverUsageLocation> m_dictCoverLocation;
  157.         CXMLAttrReader<EFireMode>           m_dictFireMode;
  158.         CXMLAttrReader<ELookMotivation>     m_dictLook;
  159.         CXMLAttrReader<EAIRegister>         m_dictRegister;
  160.         CXMLAttrReader<ESignalFilter>       m_dictSignalFilter;
  161.         CXMLAttrReader<EStance>             m_dictStance;
  162.         CXMLAttrReader<float>               m_dictUrgency;
  163.  
  164. public:
  165.         CGoalOpXMLReader();
  166.  
  167.         template<typename T>
  168.         T Get(const XmlNodeRef& node, const char* szAttrName, T defaultValue)
  169.         {
  170.                 T value;
  171.                 if (node->getAttr(szAttrName, value))
  172.                 {
  173.                         return value;
  174.                 }
  175.  
  176.                 return defaultValue;
  177.         }
  178.  
  179.         template<typename T>
  180.         bool GetMandatory(const XmlNodeRef& node, const char* szAttrName, T& value)
  181.         {
  182.                 if (node->getAttr(szAttrName, value))
  183.                 {
  184.                         return true;
  185.                 }
  186.  
  187.                 AIError("Unable to get mandatory attribute '%s' of node '%s'.",
  188.                         szAttrName, node->getTag());
  189.  
  190.                 return false;
  191.         }
  192.  
  193.         bool GetAIObjectType(const XmlNodeRef& node, const char* szAttrName, unsigned short int& nValue, bool bMandatory = false)
  194.         { return m_dictAIObjectType.Get(node, szAttrName, nValue, bMandatory); }
  195.         bool GetAnimationMode(const XmlNodeRef& node, const char* szAttrName, EAnimationMode& eValue, bool bMandatory = false)
  196.         { return m_dictAnimationMode.Get(node, szAttrName, eValue, bMandatory); }
  197.         bool GetCoverLocation(const XmlNodeRef& node, const char* szAttrName, ECoverUsageLocation& eValue, bool bMandatory = false)
  198.         { return m_dictCoverLocation.Get(node, szAttrName, eValue, bMandatory); }
  199.         bool GetFireMode(const XmlNodeRef& node, const char* szAttrName, EFireMode& eValue, bool bMandatory = false)
  200.         { return m_dictFireMode.Get(node, szAttrName, eValue, bMandatory); }
  201.         bool GetLook(const XmlNodeRef& node, const char* szAttrName, ELookMotivation& eValue, bool bMandatory = false)
  202.         { return m_dictLook.Get(node, szAttrName, eValue, bMandatory); }
  203.         bool GetRegister(const XmlNodeRef& node, const char* szAttrName, EAIRegister& eValue, bool bMandatory = false)
  204.         { return m_dictRegister.Get(node, szAttrName, eValue, bMandatory); }
  205.         bool GetSignalFilter(const XmlNodeRef& node, const char* szAttrName, ESignalFilter& eValue, bool bMandatory = false)
  206.         { return m_dictSignalFilter.Get(node, szAttrName, eValue, bMandatory); }
  207.         bool GetStance(const XmlNodeRef& node, const char* szAttrName, EStance& eValue, bool bMandatory = false)
  208.         { return m_dictStance.Get(node, szAttrName, eValue, bMandatory); }
  209.         bool GetUrgency(const XmlNodeRef& node, const char* szAttrName, float& fValue, bool bMandatory = false)
  210.         { return m_dictUrgency.Get(node, szAttrName, fValue, bMandatory); }
  211.  
  212.         bool        GetBool(const XmlNodeRef& node, const char* szAttrName, bool bDefaultValue = false);
  213.         bool        GetMandatoryBool(const XmlNodeRef& node, const char* szAttrName);
  214.  
  215.         const char* GetMandatoryString(const XmlNodeRef& node, const char* szAttrName);
  216.  
  217.         enum { MANDATORY = 1 };
  218. };
  219.  
  220. // Return value type of the IGoalOp::Execute
  221. enum EGoalOpResult
  222. {
  223.         eGOR_NONE,         // Default value; should not be returned
  224.         eGOR_IN_PROGRESS,  // Keep on executing
  225.         eGOR_SUCCEEDED,    // The goalop succeeded
  226.         eGOR_FAILED,       // The goalop failed
  227.         eGOR_DONE,         // The goalop is finished (neutral, do not change result state)
  228.         eGOR_LAST
  229. };
  230.  
  231. struct IGoalOp
  232. {
  233.         virtual ~IGoalOp() {}
  234.  
  235.         virtual void          DebugDraw(CPipeUser* pPipeUser) const = 0;
  236.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser) = 0;
  237.         /// Stripped-down execute - should only be implemented if this goalop needs
  238.         /// to be really responsive (gets called every frame - i.e. on the dry update)
  239.         virtual void ExecuteDry(CPipeUser* pPipeUser) = 0;
  240.         virtual void Reset(CPipeUser* pPipeUser) = 0;
  241.         virtual void Serialize(TSerialize ser) = 0;
  242.  
  243.         virtual void ParseParams(const GoalParams& node) = 0;
  244.         virtual void ParseParam(const char* param, const GoalParams& node) = 0;
  245.  
  246. };
  247.  
  248. // (MATT) CGoalOp must be a smart pointer for it's use in containers of QGoals {2009/10/13}
  249. class CGoalOp : public IGoalOp, public _i_reference_target_t
  250. {
  251. public:
  252.         // due to poor realization of QGoal::Clone() we need to define ctors which
  253.         // does not bit-copy of _i_reference_target_t
  254.         CGoalOp(){}
  255.         CGoalOp(const CGoalOp& op) {}
  256.  
  257.         virtual void          DebugDraw(CPipeUser* pPipeUser) const                 {}
  258.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser)                         { return eGOR_DONE; }
  259.         virtual void          ExecuteDry(CPipeUser* pPipeUser)                      {}
  260.         virtual void          Reset(CPipeUser* pPipeUser)                           {}
  261.         virtual void          Serialize(TSerialize ser)                             {}
  262.  
  263.         virtual void          ParseParams(const GoalParams& node)                   {} //const XmlNodeRef &node) {};
  264.         virtual void          ParseParam(const char* param, const GoalParams& node) {} //const XmlNodeRef &value) {};
  265.  
  266. protected:
  267.         static CGoalOpXMLReader s_xml;
  268. };
  269.  
  270. class CGoalOpParallel : public CGoalOp
  271. {
  272.  
  273.         CGoalPipe* m_NextConcurrentPipe;
  274.         CGoalPipe* m_ConcurrentPipe;
  275.  
  276.         struct OpInfo
  277.         {
  278.                 bool done;
  279.                 bool blocking;
  280.  
  281.                 OpInfo() : done(false), blocking(false)
  282.                 {}
  283.         };
  284.  
  285.         std::vector<OpInfo> m_OpInfos;
  286.  
  287. public:
  288.  
  289.         CGoalOpParallel() : m_NextConcurrentPipe(0), m_ConcurrentPipe(0)
  290.         {}
  291.  
  292.         virtual ~CGoalOpParallel();
  293.  
  294.         virtual void          ParseParams(const GoalParams& node);
  295.  
  296.         void                  SetConcurrentPipe(CGoalPipe* goalPipe);
  297.  
  298.         void                  ReleaseConcurrentPipe(CPipeUser* pPipeUser, bool clearNextPipe = false);
  299.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  300.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  301.  
  302.         void                  Reset(CPipeUser* pPipeUser)
  303.         {
  304.                 ReleaseConcurrentPipe(pPipeUser, true);
  305.  
  306.                 std::vector<OpInfo> tmp;
  307.                 m_OpInfos.swap(tmp);
  308.         };
  309. };
  310.  
  311. ////////////////////////////////////////////////////////////
  312. //
  313. //                              ACQUIRE TARGET - acquires desired target, even if it is outside of view
  314. //
  315. ////////////////////////////////////////////////////////
  316. class COPAcqTarget : public CGoalOp
  317. {
  318.         string m_sTargetName;
  319.  
  320. public:
  321.         // Empty or invalid sTargetName means "use the LastOp"
  322.         COPAcqTarget(const string& sTargetName) : m_sTargetName(sTargetName) {}
  323.         COPAcqTarget(const XmlNodeRef& node) : m_sTargetName(node->getAttr("name")) {}
  324.  
  325.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  326. };
  327.  
  328. ////////////////////////////////////////////////////////////
  329. //
  330. //                              APPROACH - makes agent approach to "distance" from current att target
  331. //
  332. ////////////////////////////////////////////////////////
  333. class COPApproach : public CGoalOp
  334. {
  335. public:
  336.         COPApproach(float fEndDistance, float fEndAccuracy = 1.f, float fDuration = 0.0f,
  337.                     bool bUseLastOpResult = false, bool bLookAtLastOp = false,
  338.                     bool bForceReturnPartialPath = false, bool bStopOnAnimationStart = false, const char* szNoPathSignalText = 0);
  339.         COPApproach(const XmlNodeRef& node);
  340.         virtual ~COPApproach() { Reset(0); }
  341.  
  342.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  343.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  344.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  345.         virtual void          Reset(CPipeUser* pPipeUser);
  346.         virtual void          Serialize(TSerialize ser);
  347.  
  348. private:
  349.         float  m_fLastDistance;
  350.         float  m_fInitialDistance;
  351.         bool   m_bUseLastOpResult;
  352.         bool   m_bLookAtLastOp;
  353.         bool   m_stopOnAnimationStart;
  354.         float  m_fEndDistance;/// Stop short of the path end
  355.         float  m_fEndAccuracy;/// allow some error in the stopping position
  356.         float  m_fDuration; /// Stop after this time (0 means disabled)
  357.         bool   m_bForceReturnPartialPath;
  358.         string m_noPathSignalText;
  359.         int    m_looseAttentionId;
  360.  
  361.         float GetEndDistance(CPipeUser* pPipeUser) const;
  362.  
  363.         // set to true when the path is first found
  364.         bool         m_bPathFound;
  365.  
  366.         COPTrace*    m_pTraceDirective;
  367.         COPPathFind* m_pPathfindDirective;
  368. };
  369.  
  370. ////////////////////////////////////////////////////////////
  371. //
  372. // FOLLOWPATH - makes agent follow the predefined path stored in the operand
  373. //
  374. ////////////////////////////////////////////////////////
  375.  
  376. class COPFollowPath : public CGoalOp
  377. {
  378. public:
  379.         /// pathFindToStart: whether the operand should path-find to the start of the path, or just go there in a straight line
  380.         /// reverse: whether the operand should navigate the path from the first point to the last, or in reverse
  381.         /// startNearest: whether the operand should start from the first point on the path, or from the nearest point on the path to his current location
  382.         /// loops: how many times to traverse the path (goes round in a loop)
  383.         COPFollowPath(bool pathFindToStart, bool reverse, bool startNearest, int loops, float fEndAccuracy, bool bUsePointList, bool bControlSpeed, float desiredSpeedOnPath);
  384.         COPFollowPath(const XmlNodeRef& node);
  385.         COPFollowPath(const COPFollowPath& rhs);
  386.         virtual ~COPFollowPath() { Reset(0); }
  387.  
  388.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  389.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  390.         virtual void          Reset(CPipeUser* pPipeUser);
  391.         virtual void          Serialize(TSerialize ser);
  392.  
  393. private:
  394.  
  395.         COPTrace*             m_pTraceDirective;
  396.         COPPathFind*          m_pPathFindDirective;
  397.         CStrongRef<CAIObject> m_refPathStartPoint;
  398.         bool                  m_pathFindToStart;
  399.         bool                  m_reversePath;
  400.         bool                  m_startNearest;
  401.         bool                  m_bUsePointList;
  402.         bool                  m_bControlSpeed;
  403.         int                   m_loops;
  404.         int                   m_loopCounter;
  405.         int                   m_notMovingTimeMs;
  406.         CTimeValue            m_lastTime;
  407.         bool                  m_returningToPath;
  408.         float                 m_fEndAccuracy;
  409.         float                 m_fDesiredSpeedOnPath;
  410.  
  411. };
  412.  
  413. ////////////////////////////////////////////////////////////
  414. //
  415. //                              BACKOFF - makes agent back off to "distance" from current att target
  416. //
  417. ////////////////////////////////////////////////////////
  418. class COPBackoff : public CGoalOp
  419. {
  420. public:
  421.         /// If distance < 0 then the backoff is done from the agent's current position,
  422.         /// else it is done from the target position.
  423.         /// If duration > 0 then backoff stops after that duration
  424.         COPBackoff(float distance, float duration = 0.f, int filter = 0, float minDistance = 0.f);
  425.         COPBackoff(const XmlNodeRef& node);
  426.         COPBackoff(const COPBackoff& rhs);
  427.         virtual ~COPBackoff() { Reset(0); }
  428.  
  429.         virtual void          Reset(CPipeUser* pPipeUser);
  430.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  431.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  432.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  433.         virtual void          Serialize(TSerialize ser);
  434.  
  435. private:
  436.         void ResetNavigation(CPipeUser* pPipeUser);
  437.         void ResetMoveDirections();
  438.  
  439. private:
  440.         bool                  m_bUseTargetPosition; // distance from target or from own current position
  441.         int                   m_iDirection;
  442.         int                   m_iCurrentDirectionIndex;
  443.         std::vector<int>      m_MoveDirections;
  444.  
  445.         float                 m_fDistance;
  446.         float                 m_fDuration;
  447.         CTimeValue            m_fInitTime;
  448.         CTimeValue            m_fLastUpdateTime;
  449.         bool                  m_bUseLastOp;
  450.         bool                  m_bLookForward;
  451.         Vec3                  m_moveStart;
  452.         Vec3                  m_moveEnd;
  453.         int                   m_currentDirMask;
  454.         float                 m_fMinDistance;
  455.         Vec3                  m_vBestFailedBackoffPos;
  456.         float                 m_fMaxDistanceFound;
  457.         bool                  m_bTryingLessThanMinDistance;
  458.         int                   m_looseAttentionId;
  459.         bool                  m_bRandomOrder;
  460.         bool                  m_bCheckSlopeDistance;
  461.  
  462.         COPTrace*             m_pTraceDirective;
  463.         COPPathFind*          m_pPathfindDirective;
  464.         CStrongRef<CAIObject> m_refBackoffPoint;
  465. };
  466.  
  467. ////////////////////////////////////////////////////////////
  468. //
  469. //                              TIMEOUT - counts down a timer...
  470. //
  471. ////////////////////////////////////////////////////////
  472. class COPTimeout : public CGoalOp
  473. {
  474.         CTimeValue m_startTime;
  475.         float      m_fIntervalMin, m_fIntervalMax;
  476.         int        m_actualIntervalMs;
  477.  
  478. public:
  479.         COPTimeout(float fIntervalMin, float fIntervalMax = 0.f);
  480.         COPTimeout(const XmlNodeRef& node);
  481.  
  482.         virtual EGoalOpResult Execute(CPipeUser*);
  483.         virtual void          Reset(CPipeUser*);
  484.         virtual void          Serialize(TSerialize ser);
  485. };
  486.  
  487. ////////////////////////////////////////////////////////////
  488. //
  489. //                              STRAFE makes agent strafe left or right (1,-1)... 0 stops strafing
  490. //
  491. ////////////////////////////////////////////////////////
  492. class COPStrafe : public CGoalOp
  493. {
  494.         float m_fDistanceStart;
  495.         float m_fDistanceEnd;
  496.         bool  m_bStrafeWhileMoving;
  497.  
  498. public:
  499.         COPStrafe(float fDistanceStart, float fDistanceEnd, bool bStrafeWhileMoving);
  500.         COPStrafe(const XmlNodeRef& node);
  501.  
  502.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  503. };
  504.  
  505. ////////////////////////////////////////////////////////////
  506. //
  507. //                              FIRECMD - 1 allows agent to fire, 0 forbids agent to fire
  508. //
  509. ////////////////////////////////////////////////////////
  510. class COPFireCmd : public CGoalOp
  511. {
  512.         EFireMode  m_eFireMode;
  513.         bool       m_bUseLastOp;
  514.  
  515.         float      m_fIntervalMin;
  516.         float      m_fIntervalMax;
  517.         int        m_actualIntervalMs;
  518.         CTimeValue m_startTime;
  519.  
  520. public:
  521.         COPFireCmd(EFireMode eFireMode, bool bUseLastOp, float fIntervalMin, float fIntervalMax);
  522.         COPFireCmd(const XmlNodeRef& node);
  523.  
  524.         virtual void          Reset(CPipeUser* pPipeUser);
  525.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  526. };
  527.  
  528. ////////////////////////////////////////////////////////////
  529. //
  530. //                              BODYCMD - controls agents stance (0- stand, 1-crouch, 2-prone)
  531. //
  532. ////////////////////////////////////////////////////////
  533. class COPBodyCmd : public CGoalOp
  534. {
  535.         EStance m_nBodyStance;
  536.         bool    m_bDelayed; // this stance has to be set at the end of next/current trace
  537.  
  538. public:
  539.         COPBodyCmd(EStance bodyStance, bool bDelayed = false);
  540.         COPBodyCmd(const XmlNodeRef& node);
  541.  
  542.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  543. };
  544.  
  545. ////////////////////////////////////////////////////////////
  546. //
  547. //                              RUNCMD - makes the agent run if 1, walk if 0
  548. //
  549. ////////////////////////////////////////////////////////
  550. class COPRunCmd : public CGoalOp
  551. {
  552.         float ConvertUrgency(float speed);
  553.  
  554.         float m_fMaxUrgency;
  555.         float m_fMinUrgency;
  556.         float m_fScaleDownPathLength;
  557.  
  558. public:
  559.         COPRunCmd(float fMaxUrgency, float fMinUrgency, float fScaleDownPathLength);
  560.         COPRunCmd(const XmlNodeRef& node);
  561.  
  562.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  563. };
  564.  
  565. ////////////////////////////////////////////////////////////
  566. //
  567. //                              LOOKAROUND - looks in a random direction
  568. //
  569. ////////////////////////////////////////////////////////
  570. class COPLookAround : public CGoalOp
  571. {
  572.         float      m_fLastDot;
  573.         float      m_fLookAroundRange;
  574.         float      m_fIntervalMin, m_fIntervalMax;
  575.         float      m_fScanIntervalRange;
  576.         int        m_scanTimeOutMs;
  577.         int        m_timeOutMs;
  578.         CTimeValue m_startTime;
  579.         CTimeValue m_scanStartTime;
  580.         ELookStyle m_eLookStyle;
  581.         bool       m_breakOnLiveTarget;
  582.         bool       m_useLastOp;
  583.         float      m_lookAngle;
  584.         float      m_lookZOffset;
  585.         float      m_lastLookAngle;
  586.         float      m_lastLookZOffset;
  587.         int        m_looseAttentionId;
  588.         bool       m_bInitialized;
  589.         Vec3       m_initialDir;
  590.         bool       m_checkForObstacles;
  591.         void       UpdateLookAtTarget(CPipeUser* pPipeUser);
  592.         Vec3       GetLookAtDir(CPipeUser* pPipeUser, float angle, float dz) const;
  593.         void       SetRandomLookDir();
  594.  
  595.         ILINE void RandomizeScanTimeout()
  596.         {
  597.                 m_scanTimeOutMs = (int)((m_fScanIntervalRange + cry_random(0.2f, 1.0f)) * 1000.0f);
  598.         }
  599.  
  600.         ILINE void RandomizeTimeout()
  601.         {
  602.                 m_timeOutMs = (int)(cry_random(m_fIntervalMin, m_fIntervalMax) * 1000.0f);
  603.         }
  604.  
  605. public:
  606.         void Reset(CPipeUser* pPipeUser);
  607.         COPLookAround(float lookAtRange, float scanIntervalRange, float intervalMin, float intervalMax, bool bBodyTurn, bool breakOnLiveTarget, bool useLastOp, bool checkForObstacles);
  608.         COPLookAround(const XmlNodeRef& node);
  609.  
  610.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  611.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  612.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  613.         virtual void          Serialize(TSerialize ser);
  614. };
  615.  
  616. ////////////////////////////////////////////////////////////
  617. //
  618. //                              PATHFIND - generates a path to desired AI object
  619. //
  620. ////////////////////////////////////////////////////////
  621. class COPPathFind : public CGoalOp
  622. {
  623.         string              m_sTargetName;
  624.         CWeakRef<CAIObject> m_refTarget;
  625.         // if m_fDirectionOnlyDistance > 0, attempt to pathfind that distance in the direction
  626.         // between the supposed path start/end points
  627.         float m_fDirectionOnlyDistance;
  628.         float m_fEndTolerance;
  629.         float m_fEndDistance;
  630.         Vec3  m_vTargetPos;
  631.         Vec3  m_vTargetOffset;
  632.  
  633.         int   m_nForceTargetBuildingID; // if >= 0 forces the path destination to be within a particular building
  634.  
  635. public:
  636.         COPPathFind(
  637.           const char* szTargetName,
  638.           CAIObject* pTarget = 0,
  639.           float fEndTolerance = 0.f,
  640.           float fEndDistance = 0.f,
  641.           float fDirectionOnlyDistance = 0.f
  642.           );
  643.         COPPathFind(const XmlNodeRef& node);
  644.  
  645.         virtual void          Reset(CPipeUser* pPipeUser);
  646.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  647.         virtual void          Serialize(TSerialize ser);
  648.  
  649.         void                  SetForceTargetBuildingId(int nForceTargetBuildingID) { m_nForceTargetBuildingID = nForceTargetBuildingID; }
  650.         void                  SetTargetOffset(const Vec3& vTargetOffset)           { m_vTargetOffset = vTargetOffset; }
  651.  
  652.         bool m_bWaitingForResult;
  653. };
  654.  
  655. ////////////////////////////////////////////////////////////
  656. //
  657. //                              LOCATE - locates an aiobject in the map
  658. //
  659. ////////////////////////////////////////////////////////
  660. class COPLocate : public CGoalOp
  661. {
  662.         string             m_sName;
  663.         unsigned short int m_nObjectType;
  664.         float              m_fRange;
  665.         bool               m_bWarnIfFailed;
  666.  
  667. public:
  668.         COPLocate(const char* szName, unsigned short int nObjectType = 0, float fRange = 0.f);
  669.         COPLocate(const XmlNodeRef& node);
  670.  
  671.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  672. };
  673.  
  674. ////////////////////////////////////////////////////////////
  675. //
  676. //                              IGNOREALL - 1, puppet does not reevaluate threats, 0 evaluates again
  677. //
  678. ////////////////////////////////////////////////////////
  679. class COPIgnoreAll : public CGoalOp
  680. {
  681.         bool m_bIgnoreAll;
  682.  
  683. public:
  684.         COPIgnoreAll(bool bIgnoreAll) : m_bIgnoreAll(bIgnoreAll) {}
  685.         COPIgnoreAll(const XmlNodeRef& node) : m_bIgnoreAll(s_xml.GetBool(node, "id", true)) {}
  686.  
  687.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  688. };
  689.  
  690. ////////////////////////////////////////////////////////////
  691. //
  692. //                              SIGNAL - send a signal to himself or other agents
  693. //
  694. ////////////////////////////////////////////////////////
  695. class COPSignal : public CGoalOp
  696. {
  697.         int           m_nSignalID;
  698.         string        m_sSignal;
  699.         ESignalFilter m_cFilter;
  700.         bool          m_bSent;
  701.         int           m_iDataValue;
  702.  
  703. public:
  704.         COPSignal(int nSignalID, const string& sSignal, ESignalFilter cFilter, int iDataValue) :
  705.                 m_nSignalID(nSignalID), m_sSignal(sSignal), m_cFilter(cFilter), m_bSent(false), m_iDataValue(iDataValue) {}
  706.         COPSignal(const XmlNodeRef& node);
  707.  
  708.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  709. };
  710.  
  711. ////////////////////////////////////////////////////////////
  712. //
  713. //                              SCRIPT - execute a piece of script
  714. //
  715. ////////////////////////////////////////////////////////
  716. class COPScript : public CGoalOp
  717. {
  718.         string m_scriptCode;
  719.  
  720. public:
  721.         COPScript(const string& scriptCode);
  722.         COPScript(const XmlNodeRef& node);
  723.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  724. };
  725.  
  726. ////////////////////////////////////////////////////////////
  727. //
  728. //                              DEVALUE - devalues current attention target
  729. //
  730. ////////////////////////////////////////////////////////
  731. class COPDeValue : public CGoalOp
  732. {
  733.         bool m_bDevaluePuppets;
  734.         bool m_bClearDevalued;
  735.  
  736. public:
  737.         COPDeValue(int nPuppetsAlso = 0, bool bClearDevalued = false);
  738.         COPDeValue(const XmlNodeRef& goalOpNode);
  739.  
  740.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  741. };
  742.  
  743. #if 0
  744. // deprecated and won't compile at all...
  745.  
  746. ////////////////////////////////////////////////////////////
  747. //
  748. //                      HIDE - makes agent find closest hiding place and then hide there
  749. //
  750. ////////////////////////////////////////////////////////
  751. class COPHide : public CGoalOp
  752. {
  753.         CStrongRef<CAIObject> m_refHideTarget;
  754.         Vec3                  m_vHidePos;
  755.         Vec3                  m_vLastPos;
  756.         float                 m_fSearchDistance;
  757.         float                 m_fMinDistance;
  758.         int                   m_nEvaluationMethod;
  759.         COPPathFind*          m_pPathFindDirective;
  760.         COPTrace*             m_pTraceDirective;
  761.         bool                  m_bLookAtHide;
  762.         bool                  m_bLookAtLastOp;
  763.         bool                  m_bAttTarget;
  764.         bool                  m_bEndEffect;
  765.         int                   m_iActionId;
  766.         int                   m_looseAttentionId;
  767.  
  768. public:
  769.         COPHide(float distance, float minDistance, int method, bool bExact, bool bLookatLastOp)
  770.         {
  771.                 m_fSearchDistance = distance;
  772.                 m_nEvaluationMethod = method;
  773.                 m_fMinDistance = minDistance;
  774.                 m_pPathFindDirective = 0;
  775.                 m_pTraceDirective = 0;
  776.                 m_bLookAtHide = bExact;
  777.                 m_bLookAtLastOp = bLookatLastOp;
  778.                 m_iActionId = 0;
  779.                 m_looseAttentionId = 0;
  780.                 m_vHidePos.zero();
  781.                 m_vLastPos.zero();
  782.                 m_bAttTarget = false;
  783.                 m_bEndEffect = false;
  784.         }
  785.  
  786.         EGoalOpResult Execute(CPipeUser* pPipeUser);
  787.         virtual void  ExecuteDry(CPipeUser* pPipeUser);
  788.         virtual void  Reset(CPipeUser* pPipeUser);
  789.         virtual void  Serialize(TSerialize ser);
  790.  
  791. private:
  792.         void CreateHideTarget(string sName, const Vec3& vPos);
  793.         bool IsBadHiding(CPipeUser* pPipeUser);
  794. };
  795. #endif // 0
  796.  
  797. ////////////////////////////////////////////////////////////
  798. //
  799. //                      TacticalPos - makes agent find a tactical position (and go there)
  800. //
  801. ///////////////////////////////////////////////////////////
  802.  
  803. class COPTacticalPos : public CGoalOp
  804. {
  805.         // Evaluation, pathfinding and moving to the point is regulated by a state machine
  806.         enum eTacticalPosState
  807.         {
  808.                 eTPS_INVALID,
  809.                 eTPS_QUERY_INIT,
  810.                 eTPS_QUERY,
  811.                 eTPS_PATHFIND_INIT,
  812.                 eTPS_PATHFIND,
  813.                 eTPS_TRACE_INIT,
  814.                 eTPS_TRACE,
  815.         };
  816.  
  817.         int                         m_iOptionUsed;               // Stored so that later signals (say, on reaching point) can give the option number
  818.         CStrongRef<CAIObject>       m_refHideTarget;
  819.         COPPathFind*                m_pPathFindDirective;
  820.         COPTrace*                   m_pTraceDirective;
  821.         bool                        m_bLookAtHide;
  822.         EAIRegister                 m_nReg;
  823.         eTacticalPosState           m_state;
  824.         CTacticalPointQueryInstance m_queryInstance;             // Help that managed the async queries
  825.         Vec3                        m_vLastHidePos;
  826.  
  827. public:
  828.         COPTacticalPos(int tacQueryID, EAIRegister nReg);
  829.         COPTacticalPos(const XmlNodeRef& node);
  830.         COPTacticalPos(const COPTacticalPos& rhs);
  831.         virtual ~COPTacticalPos() { Reset(NULL); }
  832.  
  833.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  834.         void                  QueryDryUpdate(CPipeUser* pPipeUser);
  835.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  836.         virtual void          Reset(CPipeUser* pPipeUser);
  837.         bool                  IsBadHiding(CPipeUser* pPipeUser);
  838.         virtual void          Serialize(TSerialize ser);
  839.  
  840. protected:
  841.         enum { eTPGOpState_NoPointFound, eTPGOpState_PointFound, eTPGOpState_DestinationReached };
  842.         void SendStateSignal(CPipeUser* pPipeUser, int nState);
  843. };
  844.  
  845. ////////////////////////////////////////////////////////////
  846. //
  847. //                      Look - make an agent look somewhere (operates on looktarget)
  848. //
  849. ///////////////////////////////////////////////////////////
  850.  
  851. class COPLook : public CGoalOp
  852. {
  853.         ELookStyle  m_eLookThere;
  854.         ELookStyle  m_eLookBack;
  855.         EAIRegister m_nReg;
  856.         int         m_nLookID; // keep track of this look command
  857.         bool        m_bInitialised;
  858.         float       m_fLookTime, m_fTimeLeft;
  859.  
  860. public:
  861.         COPLook(int lookMode, bool bBodyTurn, EAIRegister nReg);
  862.         COPLook(const XmlNodeRef& node);
  863.  
  864.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  865.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  866.         virtual void          Reset(CPipeUser* pPipeUser);
  867.         virtual void          Serialize(TSerialize ser);
  868. };
  869.  
  870. #if 0
  871. // deprecated and won't compile at all...
  872.  
  873. ////////////////////////////////////////////////////////////
  874. //
  875. //                      FORM - this agent creates desired formation
  876. //
  877. ////////////////////////////////////////////////////////
  878. // (MATT) Appears probably useless. Consider removing {2009/02/27}
  879. class COPForm : public CGoalOp
  880. {
  881.         string m_sName;
  882.  
  883. public:
  884.         COPForm(const char* name) : m_sName(name) {}
  885.         COPForm(const XmlNodeRef& node) : m_sName(s_xml.GetMandatoryString(node, "name")) {}
  886.  
  887.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  888. };
  889. #endif // 0
  890.  
  891. ////////////////////////////////////////////////////////////
  892. //
  893. //                      CLEAR - clears the actions for the operand puppet
  894. //
  895. ////////////////////////////////////////////////////////
  896. class COPClear : public CGoalOp
  897. {
  898.         string m_sName;
  899.  
  900. public:
  901.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  902. };
  903.  
  904. ////////////////////////////////////////////////////////////
  905. //
  906. //                      LOOKAT - look toward a specified direction
  907. //
  908. ////////////////////////////////////////////////////////
  909. class COPLookAt : public CGoalOp
  910. {
  911.         float      m_fStartAngle;
  912.         float      m_fEndAngle;
  913.         float      m_fLastDot;
  914.         float      m_fAngleThresholdCos;
  915.         CTimeValue m_startTime;
  916.         ELookStyle m_eLookStyle;
  917.  
  918.         bool       m_bUseLastOp;
  919.         bool       m_bContinuous;
  920.         bool       m_bInitialized;
  921.         bool       m_bUseBodyDir;
  922.         bool       m_bYawOnly;
  923.  
  924.         void ResetLooseTarget(CPipeUser* pPipeUser, bool bForceReset = false);
  925.  
  926. public:
  927.         COPLookAt(float fStartAngle, float fEndAngle, int mode = 0, bool bBodyTurn = true, bool bUseLastOp = false);
  928.         COPLookAt(const XmlNodeRef& node);
  929.  
  930.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  931.         virtual void          Reset(CPipeUser* pPipeUser);
  932.         virtual void          Serialize(TSerialize ser);
  933. };
  934.  
  935. ////////////////////////////////////////////////////////////
  936. //
  937. //                              CONTINUOUS - continuous movement, keep on going in last movement direction. Not to stop while tracing path.
  938. //
  939. ////////////////////////////////////////////////////////
  940. class COPContinuous : public CGoalOp
  941. {
  942.         bool m_bKeepMoving;
  943.  
  944. public:
  945.         COPContinuous(bool bKeepMoving);
  946.         COPContinuous(const XmlNodeRef& goalOpNode);
  947.  
  948.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  949.         virtual void          Reset(CPipeUser* pPipeUser) {}
  950. };
  951.  
  952. #if 0
  953. // deprecated and won't compile at all...
  954.  
  955. ////////////////////////////////////////////////////////////
  956. //
  957. //                              STEER - Makes the puppet try to reach a point and stay near it all the time using the "steering behavior engine"
  958. //
  959. ////////////////////////////////////////////////////////
  960. class COPSteer : public CGoalOp
  961. {
  962. public:
  963.         COPSteer(float fSteerDistance = 0.0f, float fPathLenLimit = 0.0f);
  964.         COPSteer(const XmlNodeRef& node);
  965.         virtual ~COPSteer();
  966.  
  967.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  968.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  969.         virtual void          Reset(CPipeUser* pPipeUser);
  970.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  971.         virtual void          Serialize(TSerialize ser);
  972.  
  973. private:
  974.         void RegeneratePath(CPipeUser* pPipeUser, const Vec3& destination);
  975.  
  976.         Vec3         m_vLastUsedTargetPos;
  977.         CTimeValue   m_fLastRegenTime;
  978.  
  979.         float        m_fPathLenLimit;
  980.         float        m_fSteerDistanceSqr;
  981.         float        m_fLastDistance;
  982.         float        m_fMinEndDistance, m_fMaxEndDistance;
  983.         float        m_fEndAccuracy;
  984.         bool         m_bNeedHidespot;
  985.         bool         m_bFirstExec;
  986.  
  987.         COPTrace*    m_pTraceDirective;
  988.         COPPathFind* m_pPathfindDirective;
  989.         CAIObject*   m_pPosDummy;
  990. };
  991. #endif // 0
  992.  
  993. ////////////////////////////////////////////////////////
  994. //
  995. //      waitsignal - waits for a signal and counts down a timer...
  996. //
  997. ////////////////////////////////////////////////////////
  998. class COPWaitSignal : public CGoalOp
  999. {
  1000.         string m_sSignal;
  1001.         enum _edMode
  1002.         {
  1003.                 edNone,
  1004.                 edString,
  1005.                 edInt,
  1006.                 edId
  1007.         }          m_edMode;
  1008.         string     m_sObjectName;
  1009.         int        m_iValue;
  1010.         EntityId   m_nID;
  1011.  
  1012.         CTimeValue m_startTime;
  1013.         int        m_intervalMs;
  1014.         bool       m_bSignalReceived;
  1015.  
  1016. public:
  1017.         COPWaitSignal(const XmlNodeRef& node);
  1018.  
  1019.         // (MATT) Note that it appears all but the first form could be removed {2008/08/09}
  1020.         COPWaitSignal(const char* sSignal, float fInterval = 0);
  1021.         COPWaitSignal(const char* sSignal, const char* sObjectName, float fInterval = 0);
  1022.         COPWaitSignal(const char* sSignal, int iValue, float fInterval = 0);
  1023.         COPWaitSignal(const char* sSignal, EntityId nID, float fInterval = 0);
  1024.  
  1025.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1026.         virtual void          Reset(CPipeUser* pPipeUser);
  1027.         virtual void          Serialize(TSerialize ser);
  1028.  
  1029.         bool                  NotifySignalReceived(CAIObject* pPipeUser, const char* szText, IAISignalExtraData* pData);
  1030. };
  1031.  
  1032. ////////////////////////////////////////////////////////
  1033. //
  1034. //      animation -  sets AG input.
  1035. //
  1036. ////////////////////////////////////////////////////////
  1037. class COPAnimation : public CGoalOp
  1038. {
  1039. protected:
  1040.         EAnimationMode m_eMode;
  1041.         string         m_sValue;
  1042.         bool           m_bIsUrgent;
  1043.  
  1044.         bool           m_bAGInputSet;
  1045.  
  1046. public:
  1047.         COPAnimation(EAnimationMode mode, const char* value, const bool isUrgent);
  1048.         COPAnimation(const XmlNodeRef& node);
  1049.  
  1050.         virtual void          Serialize(TSerialize ser);
  1051.  
  1052.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1053.         virtual void          Reset(CPipeUser* pPipeUser);
  1054. };
  1055.  
  1056. ////////////////////////////////////////////////////////
  1057. //
  1058. //      exact positioning animation to be played at the end of the path
  1059. //
  1060. ////////////////////////////////////////////////////////
  1061. class COPAnimTarget : public CGoalOp
  1062. {
  1063.         string m_sAnimName;
  1064.         float  m_fStartWidth;
  1065.         float  m_fDirectionTolerance;
  1066.         float  m_fStartArcAngle;
  1067.         Vec3   m_vApproachPos;
  1068.         bool   m_bSignal;
  1069.         bool   m_bAutoAlignment;
  1070.  
  1071. public:
  1072.         COPAnimTarget(bool signal, const char* animName, float startWidth, float dirTolerance, float startArcAngle, const Vec3& approachPos, bool autoAlignment);
  1073.         COPAnimTarget(const XmlNodeRef& node);
  1074.  
  1075.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1076.         virtual void          Serialize(TSerialize ser);
  1077. };
  1078.  
  1079. ////////////////////////////////////////////////////////
  1080. //
  1081. //      wait for group of goals to be executed
  1082. //
  1083. ////////////////////////////////////////////////////////
  1084. class COPWait : public CGoalOp
  1085. {
  1086.         EOPWaitType m_WaitType;
  1087.         int         m_BlockCount; //    number of non-blocking goals in the block
  1088.  
  1089. public:
  1090.         COPWait(int waitType, int blockCount);
  1091.         COPWait(const XmlNodeRef& node);
  1092.  
  1093.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1094.         virtual void          Serialize(TSerialize ser);
  1095. };
  1096.  
  1097. #if 0
  1098. // deprecated and won't compile at all...
  1099.  
  1100. ////////////////////////////////////////////////////////////
  1101. //
  1102. // PROXIMITY - Send signal on proximity
  1103. //
  1104. ////////////////////////////////////////////////////////
  1105.  
  1106. class COPProximity : public CGoalOp
  1107. {
  1108. public:
  1109.         COPProximity(float radius, const string& signalName, bool signalWhenDisabled, bool visibleTargetOnly);
  1110.         COPProximity(const XmlNodeRef& node);
  1111.  
  1112.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1113.         virtual void          Reset(CPipeUser* pPipeUser);
  1114.         virtual void          Serialize(TSerialize ser);
  1115.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  1116.  
  1117. private:
  1118.         float               m_radius;
  1119.         bool                m_triggered;
  1120.         bool                m_signalWhenDisabled;
  1121.         bool                m_visibleTargetOnly;
  1122.         string              m_signalName;
  1123.         CWeakRef<CAIObject> m_refProxObject;
  1124. };
  1125.  
  1126. ////////////////////////////////////////////////////////////
  1127. //
  1128. //                              MOVETOWARDS - move specified distance towards last op result
  1129. //
  1130. ////////////////////////////////////////////////////////
  1131. class COPMoveTowards : public CGoalOp
  1132. {
  1133. public:
  1134.         COPMoveTowards(float distance, float duration);
  1135.         COPMoveTowards(const XmlNodeRef& node);
  1136.         virtual ~COPMoveTowards() { Reset(0); }
  1137.  
  1138.         virtual void          Reset(CPipeUser* pPipeUser);
  1139.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1140.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  1141.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  1142.         virtual void          Serialize(TSerialize ser);
  1143.  
  1144. private:
  1145.         void  ResetNavigation(CPipeUser* pPipeUser);
  1146.  
  1147.         float GetEndDistance(CPipeUser* pPipeUser) const;
  1148.  
  1149.         float        m_distance;
  1150.         float        m_duration;
  1151.         int          m_looseAttentionId;
  1152.         Vec3         m_moveStart;
  1153.         Vec3         m_moveEnd;
  1154.         float        m_moveDist;
  1155.         float        m_moveSearchRange;
  1156.  
  1157.         COPTrace*    m_pTraceDirective;
  1158.         COPPathFind* m_pPathfindDirective;
  1159. };
  1160.  
  1161. ////////////////////////////////////////////////////////////
  1162. //
  1163. // DODGE - Dodges a target
  1164. //
  1165. ////////////////////////////////////////////////////////
  1166.  
  1167. class COPDodge : public CGoalOp
  1168. {
  1169. public:
  1170.         COPDodge(float distance, bool useLastOpAsBackup);
  1171.         COPDodge(const XmlNodeRef& node);
  1172.         virtual ~COPDodge() { Reset(0); }
  1173.  
  1174.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1175.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  1176.         virtual void          Reset(CPipeUser* pPipeUser);
  1177.         virtual void          Serialize(TSerialize ser);
  1178.         virtual void          DebugDraw(CPipeUser* pPipeUser) const;
  1179.  
  1180. private:
  1181.  
  1182.         typedef std::pair<Vec3, float> Vec3FloatPair;
  1183.  
  1184.         bool OverlapSegmentAgainstAvoidPos(const Vec3& from, const Vec3& to, float rad, const std::vector<Vec3FloatPair>& avoidPos);
  1185.         void GetNearestActors(CAIActor* pSelf, const Vec3& pos, float radius, std::vector<Vec3FloatPair>& positions);
  1186.  
  1187.         float                      m_distance;
  1188.         bool                       m_useLastOpAsBackup;
  1189.         float                      m_endAccuracy;
  1190.         CTimeValue                 m_lastTime;
  1191.         float                      m_notMovingTime;
  1192.         COPTrace*                  m_pTraceDirective;
  1193.         std::vector<Vec3FloatPair> m_avoidPos;
  1194.  
  1195.         std::vector<Vec3>          m_DEBUG_testSegments;
  1196.         Matrix33                   m_basis;
  1197.         Vec3                       m_targetPos;
  1198.         Vec3                       m_targetView;
  1199.         Vec3                       m_bestPos;
  1200. };
  1201.  
  1202. ////////////////////////////////////////////////////////////
  1203. //
  1204. // COMPANIONSTICK - Special stick for companion that introduces
  1205. //      speed control and rubberband-like movement
  1206. //
  1207. ////////////////////////////////////////////////////////
  1208.  
  1209. class COPCompanionStick : public CGoalOp
  1210. {
  1211. public:
  1212.         COPCompanionStick(float fNotReactingDistance, float fForcedMoveDistance, float fLeaderInfluenceRange);
  1213.         COPCompanionStick(const XmlNodeRef& node);
  1214.         virtual ~COPCompanionStick();
  1215.  
  1216.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1217.         virtual void          ExecuteDry(CPipeUser* pPipeUser);
  1218.         virtual void          Reset(CPipeUser* pPipeUser);
  1219.         virtual void          Serialize(TSerialize ser);
  1220.         virtual void          DebugDraw(CPipeUser* pOperandconst) const;
  1221.  
  1222. private:
  1223.         void RegeneratePath(CPipeUser* pPipeUser, const Vec3& destination);
  1224.         void AdjustSpeed(CPipeUser* pPipeUser);
  1225.  
  1226.         Vec3         m_vLastUsedTargetPos;
  1227.         Vec3         m_vCurrentTargetPos;           // caution: different from the point used to generate path
  1228.         CTimeValue   m_fLastRegenTime;
  1229.  
  1230.         float        m_fMoveWillingness;
  1231.         float        m_fLeaderInfluenceRange;
  1232.         float        m_fNotReactingDistance;
  1233.         float        m_fForcedMoveDistance;
  1234.  
  1235.         float        m_fPathLenLimit;
  1236.         float        m_fSteerDistanceSqr;
  1237.         float        m_fLastDistance;
  1238.         float        m_fMinEndDistance, m_fMaxEndDistance;
  1239.         float        m_fEndAccuracy;
  1240.         bool         m_bNeedHidespot;
  1241.         bool         m_bFirstExec;
  1242.  
  1243.         COPTrace*    m_pTraceDirective;
  1244.         COPPathFind* m_pPathfindDirective;
  1245.         CAIObject*   m_pPosDummy;
  1246. };
  1247.  
  1248. #endif // 0
  1249.  
  1250. ////////////////////////////////////////////////////////////
  1251. //
  1252. //                      COMMUNICATION - play AI communication
  1253. //
  1254. ////////////////////////////////////////////////////////
  1255. class COPCommunication : public CGoalOp, ICommunicationManager::ICommInstanceListener
  1256. {
  1257.         CommID                           m_commID;
  1258.         CommChannelID                    m_channelID;
  1259.         SCommunicationRequest::EOrdering m_ordering;
  1260.         float                            m_expirity;
  1261.         float                            m_minSilence;
  1262.  
  1263.         bool                             m_ignoreSound;
  1264.         bool                             m_ignoreAnim;
  1265.  
  1266.         float                            m_timeout;
  1267.         CTimeValue                       m_startTime;
  1268.  
  1269.         CommPlayID                       m_playID;
  1270.  
  1271.         bool                             m_bInitialized;
  1272.  
  1273.         //Set on communication end
  1274.         bool m_commFinished;
  1275.         bool m_waitUntilFinished;
  1276.  
  1277. public:
  1278.         COPCommunication(const char* commName, const char* channelName, const char* ordering = "unordered", float expirity = 0.0f, float minSilence = -1.0f, bool ignoreSound = false, bool ignoreAnim = false);
  1279.         COPCommunication(const XmlNodeRef& node);
  1280.  
  1281.         virtual ~COPCommunication(){ Reset(0); }
  1282.  
  1283.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1284.         virtual void          Serialize(TSerialize ser);
  1285.  
  1286.         virtual void          Reset(CPipeUser* pPipeUser);
  1287.  
  1288.         //ICommunicationManager::ICommInstanceListener
  1289.         virtual void OnCommunicationEvent(ICommunicationManager::ECommunicationEvent event, EntityId actorID,
  1290.                                           const CommPlayID& playID);
  1291.         //~ICommunicationManager::ICommInstanceListener
  1292.  
  1293. };
  1294.  
  1295. ////////////////////////////////////////////////////////////
  1296. //
  1297. // DUMMY - Does nothing except for returning AIGOR_DONE
  1298. //
  1299. ////////////////////////////////////////////////////////
  1300.  
  1301. class COPDummy : public CGoalOp
  1302. {
  1303. public:
  1304.         virtual EGoalOpResult Execute(CPipeUser* pPipeUser);
  1305. };
  1306.  
  1307. #endif  // #ifndef __GOALOP_H_
  1308.  
downloadGoalOp.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