BVB Source Codes

CRYENGINE Show IMovementController.h Source code

Return Download CRYENGINE: download IMovementController.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Control pipe between AI and game objects.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 29:11:2005: Created by Craig Tiller
  12.  
  13. *************************************************************************/
  14.  
  15. #ifndef __IMOVEMENTCONTROLLER_H__
  16. #define __IMOVEMENTCONTROLLER_H__
  17.  
  18. #pragma once
  19.  
  20. #include "IAnimationGraph.h"
  21. #include <CryAISystem/IAgent.h> // For enums
  22. #include "ICryMannequin.h"
  23.  
  24. // ============================================================================
  25. // ============================================================================
  26.  
  27. struct SExactPositioningTarget
  28. {
  29.         SExactPositioningTarget()
  30.                 : preparing(false)
  31.                 , activated(false)
  32.                 , notAiControlledAnymore(false)
  33.                 , isNavigationalSO(false)
  34.                 , location(IDENTITY)
  35.                 , startWidth(0.0f)
  36.                 , positionWidth(0.0f)
  37.                 , positionDepth(0.0f)
  38.                 , orientationTolerance(0.0f)
  39.                 , errorVelocity(ZERO)
  40.                 , errorRotationalVelocity(IDENTITY)
  41.         {}
  42.         uint32              preparing              : 1;
  43.         uint32              activated              : 1; // == action entered
  44.         mutable uint32      notAiControlledAnymore : 1;
  45.         uint32              isNavigationalSO       : 1;
  46.         QuatT               location;
  47.         float               startWidth;
  48.         float               positionWidth;
  49.         float               positionDepth;
  50.         float               orientationTolerance;
  51.         Vec3                errorVelocity;
  52.         Quat                errorRotationalVelocity;
  53.         _smart_ptr<IAction> pAction;
  54. };
  55.  
  56. typedef uint32 TExactPositioningQueryID;
  57.  
  58. struct IExactPositioningListener
  59. {
  60.         virtual ~IExactPositioningListener() {}
  61.  
  62.         virtual void ExactPositioningQueryComplete(TExactPositioningQueryID queryID, bool succeeded) = 0;
  63.         virtual void ExactPositioningNotifyFinishPoint(const Vec3& pt) = 0;
  64. };
  65.  
  66. // Note:
  67. // IMPORTANT: wherever "Target" is mentioned in this file, we talk
  68. // about a target position, *not* direction.
  69. struct SActorTargetParams
  70. {
  71.         enum type_uninitialized { UNINITIALIZED };
  72.  
  73.         SActorTargetParams() :
  74.                 location(ZERO),
  75.                 direction(FORWARD_DIRECTION),
  76.                 vehicleSeat(0),
  77.                 speed(-1.0f),
  78.                 directionTolerance(0.0f),
  79.                 startArcAngle(0.0f),
  80.                 startWidth(0.0f),
  81.                 stance(STANCE_NULL),
  82.                 pQueryStart(NULL),
  83.                 pQueryEnd(NULL),
  84.                 prepareRadius(3.0f),//
  85.                 projectEnd(false),
  86.                 navSO(false),
  87.                 completeWhenActivated(true)
  88.         {
  89.         }
  90.  
  91.         // non-default constructor to allow CMovementRequest to avoid unnecessary initialization of
  92.         // vars in SActorTargetParams
  93.         // cppcheck-suppress uninitMemberVar
  94.         ILINE SActorTargetParams(type_uninitialized) {}
  95.  
  96.         Vec3                      location; // target location
  97.         Vec3                      direction;
  98.         string                    vehicleName;
  99.         int                       vehicleSeat;
  100.         float                     speed;
  101.         float                     directionTolerance; // allowed direction tolerance (radians)
  102.         float                     startArcAngle;      // arc angle used to bend the starting line (radians)
  103.         float                     startWidth;         // width of the starting line
  104.         EStance                   stance;
  105.         TExactPositioningQueryID* pQueryStart;
  106.         TExactPositioningQueryID* pQueryEnd;
  107.         _smart_ptr<IAction>       pAction;
  108.         float                     prepareRadius;
  109.         bool                      projectEnd;
  110.         bool                      navSO;                 // we allow bigger errors in start position while passing through
  111.                                                          // a smart object to avoid too much slowing down in front of it
  112.         bool                      completeWhenActivated; // true when you want the movementcontroller to continue working as normal as soon as the action is entered (instead of waiting for it to finish).
  113. };
  114.  
  115. struct SMannequinTagRequest
  116. {
  117.         SMannequinTagRequest()
  118.                 : clearTags(TAG_STATE_EMPTY)
  119.                 , setTags(TAG_STATE_EMPTY)
  120.         {
  121.         }
  122.  
  123.         SMannequinTagRequest(const TagState& clearTags_, const TagState& setTags_)
  124.                 : clearTags(clearTags_)
  125.                 , setTags(setTags_)
  126.         {
  127.         }
  128.  
  129.         void Clear()
  130.         {
  131.                 clearTags = TAG_STATE_EMPTY;
  132.                 setTags = TAG_STATE_EMPTY;
  133.         }
  134.  
  135.         TagState clearTags;
  136.         TagState setTags;
  137. };
  138.  
  139. class CMovementRequest
  140. {
  141. public:
  142.         ILINE CMovementRequest()
  143.                 : m_flags(0)
  144.                 , m_desiredSpeed(0.0f)
  145.                 , m_targetSpeed(0.0f)
  146.                 , m_lookImportance(0.0f)
  147.                 , m_distanceToPathEnd(0.0f)
  148.                 , m_desiredLean(0.0f)
  149.                 , m_desiredPeekOver(0.0f)
  150.                 , m_pseudoSpeed(0.0f)
  151.                 , m_alertness(0)
  152.                 , m_alertnessLast(0)
  153.                 , m_context(0)
  154.                 , m_actorTarget(SActorTargetParams::UNINITIALIZED)
  155.         {
  156.         }
  157.  
  158.         // was anything set at all in this request?`
  159.         bool IsEmpty()
  160.         {
  161.                 return m_flags == 0;
  162.         }
  163.  
  164.         void SetAlertness(int alertness)
  165.         {
  166.                 m_alertness = alertness;
  167.         }
  168.  
  169.         ILINE int GetAlertness()
  170.         {
  171.                 return m_alertness;
  172.         }
  173.  
  174.         ILINE bool AlertnessChanged()
  175.         {
  176.                 bool ret(m_alertnessLast != m_alertness);
  177.                 m_alertnessLast = m_alertness;
  178.                 return ret;
  179.         }
  180.  
  181.         void SetActorTarget(const SActorTargetParams& params)
  182.         {
  183.                 m_actorTarget = params;
  184.                 SetFlag(eMRF_ActorTarget);
  185.                 ClearFlag(eMRF_RemoveActorTarget);
  186.         }
  187.  
  188.         void ClearActorTarget()
  189.         {
  190.                 ClearFlag(eMRF_ActorTarget);
  191.                 SetFlag(eMRF_RemoveActorTarget);
  192.         }
  193.  
  194.         void SetLookTarget(const Vec3& position, float importance = 1.0f)
  195.         {
  196.                 m_lookTarget = position;
  197.                 m_lookImportance = importance;
  198.                 SetFlag(eMRF_LookTarget);
  199.                 ClearFlag(eMRF_RemoveLookTarget);
  200.         }
  201.  
  202.         void ClearLookTarget()
  203.         {
  204.                 SetFlag(eMRF_RemoveLookTarget);
  205.                 ClearFlag(eMRF_LookTarget);
  206.         }
  207.  
  208.         void SetLookStyle(ELookStyle eLookStyle)
  209.         {
  210.                 m_eLookStyle = eLookStyle;
  211.                 SetFlag(eMRF_LookStyle);
  212.                 // MTJ: Might set remove flag, but I don't think we need one
  213.         }
  214.  
  215.         void ClearLookStyle()
  216.         {
  217.                 ClearFlag(eMRF_LookStyle);
  218.                 m_eLookStyle = (ELookStyle) - 1; // Just to help debugging
  219.                 // MTJ: Might set remove flag, but I don't think we need one
  220.         }
  221.  
  222.         bool HasLookStyle()
  223.         {
  224.                 return CheckFlag(eMRF_LookStyle);
  225.         }
  226.  
  227.         ELookStyle GetLookStyle()
  228.         {
  229.                 CRY_ASSERT(HasLookStyle());
  230.                 return m_eLookStyle;
  231.         }
  232.  
  233.         void SetBodyOrientationMode(const EBodyOrientationMode bodyOrientationMode)
  234.         {
  235.                 m_bodyOrientationMode = bodyOrientationMode;
  236.                 SetFlag(eMRF_BodyOrientationMode);
  237.                 ClearFlag(eMRF_RemoveBodyOrientationMode);
  238.         }
  239.  
  240.         void ClearBodyOrientationMode()
  241.         {
  242.                 SetFlag(eMRF_RemoveBodyOrientationMode);
  243.                 ClearFlag(eMRF_BodyOrientationMode);
  244.         }
  245.  
  246.         bool HasBodyOrientationMode() const
  247.         {
  248.                 return CheckFlag(eMRF_BodyOrientationMode);
  249.         }
  250.  
  251.         EBodyOrientationMode GetBodyOrientationMode() const
  252.         {
  253.                 return m_bodyOrientationMode;
  254.         }
  255.  
  256.         void SetAimTarget(const Vec3& position)
  257.         {
  258.                 m_aimTarget = position;
  259.                 SetFlag(eMRF_AimTarget);
  260.                 ClearFlag(eMRF_RemoveAimTarget);
  261.         }
  262.  
  263.         void ClearAimTarget()
  264.         {
  265.                 ClearFlag(eMRF_AimTarget);
  266.                 SetFlag(eMRF_RemoveAimTarget);
  267.         }
  268.  
  269.         void SetBodyTarget(const Vec3& position)
  270.         {
  271.                 m_bodyTarget = position;
  272.                 SetFlag(eMRF_BodyTarget);
  273.                 ClearFlag(eMRF_RemoveBodyTarget);
  274.         }
  275.  
  276.         void ClearBodyTarget()
  277.         {
  278.                 ClearFlag(eMRF_BodyTarget);
  279.                 SetFlag(eMRF_RemoveBodyTarget);
  280.         }
  281.  
  282.         void SetFireTarget(const Vec3& position)
  283.         {
  284.                 m_fireTarget = position;
  285.                 SetFlag(eMRF_FireTarget);
  286.                 ClearFlag(eMRF_RemoveFireTarget);
  287.         }
  288.  
  289.         void ClearFireTarget()
  290.         {
  291.                 ClearFlag(eMRF_FireTarget);
  292.                 SetFlag(eMRF_RemoveFireTarget);
  293.         }
  294.  
  295.         void SetLean(float lean)
  296.         {
  297.                 m_desiredLean = lean;
  298.                 SetFlag(eMRF_DesiredLean);
  299.                 ClearFlag(eMRF_RemoveDesiredLean);
  300.         }
  301.  
  302.         void ClearLean()
  303.         {
  304.                 ClearFlag(eMRF_DesiredLean);
  305.                 SetFlag(eMRF_RemoveDesiredLean);
  306.         }
  307.  
  308.         void SetPeekOver(float peekOver)
  309.         {
  310.                 m_desiredPeekOver = peekOver;
  311.                 SetFlag(eMRF_DesiredPeekOver);
  312.                 ClearFlag(eMRF_RemoveDesiredPeekOver);
  313.         }
  314.  
  315.         void ClearPeekOver()
  316.         {
  317.                 ClearFlag(eMRF_DesiredPeekOver);
  318.                 SetFlag(eMRF_RemoveDesiredPeekOver);
  319.         }
  320.  
  321.         void SetDesiredSpeed(float speed, float targetSpeed = -1.0f)
  322.         {
  323.                 m_desiredSpeed = speed;
  324.                 m_targetSpeed = (float)__fsel(targetSpeed, targetSpeed, speed);
  325.                 SetFlag(eMRF_DesiredSpeed);
  326.                 ClearFlag(eMRF_RemoveDesiredSpeed);
  327.         }
  328.  
  329.         void ClearDesiredSpeed()
  330.         {
  331.                 ClearFlag(eMRF_DesiredSpeed);
  332.                 SetFlag(eMRF_RemoveDesiredSpeed);
  333.         }
  334.  
  335.         void SetPseudoSpeed(float speed)
  336.         {
  337.                 m_pseudoSpeed = speed;
  338.                 SetFlag(eMRF_PseudoSpeed);
  339.                 ClearFlag(eMRF_RemovePseudoSpeed);
  340.         }
  341.  
  342.         void ClearPseudoSpeed()
  343.         {
  344.                 ClearFlag(eMRF_PseudoSpeed);
  345.                 SetFlag(eMRF_RemovePseudoSpeed);
  346.         }
  347.  
  348.         void SetPrediction(const SPredictedCharacterStates& prediction)
  349.         {
  350.                 m_prediction = prediction;
  351.                 SetFlag(eMRF_Prediction);
  352.         }
  353.  
  354.         const SPredictedCharacterStates& GetPrediction() const
  355.         {
  356.                 CRY_ASSERT(HasPrediction());
  357.                 return m_prediction;
  358.         }
  359.  
  360.         void ClearPrediction()
  361.         {
  362.                 ClearFlag(eMRF_Prediction);
  363.                 SetFlag(eMRF_RemovePrediction);
  364.         }
  365.  
  366.         void AddDeltaMovement(const Vec3& direction)
  367.         {
  368.                 if (!CheckFlag(eMRF_DeltaMovement))
  369.                         m_deltaMovement = direction;
  370.                 else
  371.                         m_deltaMovement += direction;
  372.                 SetFlag(eMRF_DeltaMovement);
  373.         }
  374.  
  375.         void RemoveDeltaMovement()
  376.         {
  377.                 ClearFlag(eMRF_DeltaMovement);
  378.         }
  379.  
  380.         void AddDeltaRotation(const Ang3& rotation)
  381.         {
  382.                 if (!CheckFlag(eMRF_DeltaRotation))
  383.                         m_deltaRotation = rotation;
  384.                 else
  385.                         m_deltaRotation += rotation;
  386.                 SetFlag(eMRF_DeltaRotation);
  387.         }
  388.  
  389.         void RemoveDeltaRotation()
  390.         {
  391.                 ClearFlag(eMRF_DeltaRotation);
  392.         }
  393.  
  394.         void SetDistanceToPathEnd(float dist)
  395.         {
  396.                 m_distanceToPathEnd = dist;
  397.         }
  398.  
  399.         void ClearDistanceToPathEnd()
  400.         {
  401.                 m_distanceToPathEnd = -1.0f;
  402.         }
  403.  
  404.         void SetDirectionOffFromPath(const Vec3& dir)
  405.         {
  406.                 SetFlag(eMRF_DirectionOffPath);
  407.                 m_dirOffFromPath = dir;
  408.         }
  409.  
  410.         void ClearDirectionOffFromPath()
  411.         {
  412.                 ClearFlag(eMRF_DirectionOffPath);
  413.                 m_dirOffFromPath = Vec3(ZERO);
  414.         }
  415.  
  416.         bool HasDirectionOffFromPath() const
  417.         {
  418.                 return CheckFlag(eMRF_DirectionOffPath);
  419.         }
  420.  
  421.         void SetJump()
  422.         {
  423.                 SetFlag(eMRF_Jump);
  424.         }
  425.  
  426.         void ClearJump()
  427.         {
  428.                 ClearFlag(eMRF_Jump);
  429.         }
  430.  
  431.         void SetAllowStrafing()
  432.         {
  433.                 SetFlag(eMRF_AllowStrafing);
  434.         }
  435.  
  436.         void SetAllowStrafing(bool allow)
  437.         {
  438.                 if (allow)
  439.                         SetAllowStrafing();
  440.                 else
  441.                         ClearAllowStrafing();
  442.         }
  443.  
  444.         void ClearAllowStrafing()
  445.         {
  446.                 ClearFlag(eMRF_AllowStrafing);
  447.         }
  448.  
  449.         bool AllowStrafing() const
  450.         {
  451.                 return CheckFlag(eMRF_AllowStrafing);
  452.         }
  453.  
  454.         void SetAllowLowerBodyToTurn()
  455.         {
  456.                 SetFlag(eMRF_AllowLowerBodyToTurn);
  457.         }
  458.  
  459.         void SetAllowLowerBodyToTurn(bool allow)
  460.         {
  461.                 if (allow)
  462.                         SetAllowLowerBodyToTurn();
  463.                 else
  464.                         ClearLowerBodyToTurn();
  465.         }
  466.  
  467.         void ClearLowerBodyToTurn()
  468.         {
  469.                 ClearFlag(eMRF_AllowLowerBodyToTurn);
  470.         }
  471.  
  472.         bool AllowLowerBodyToTurn() const
  473.         {
  474.                 return CheckFlag(eMRF_AllowLowerBodyToTurn);
  475.         }
  476.  
  477.         void SetStance(EStance stance)
  478.         {
  479.                 m_stance = stance;
  480.                 SetFlag(eMRF_Stance);
  481.                 ClearFlag(eMRF_RemoveStance);
  482.         }
  483.  
  484.         void ClearStance()
  485.         {
  486.                 ClearFlag(eMRF_Stance);
  487.                 SetFlag(eMRF_RemoveStance);
  488.         }
  489.  
  490.         void SetMoveTarget(const Vec3& pos)
  491.         {
  492.                 m_moveTarget = pos;
  493.                 SetFlag(eMRF_MoveTarget);
  494.                 ClearFlag(eMRF_RemoveMoveTarget);
  495.         }
  496.  
  497.         void ClearMoveTarget()
  498.         {
  499.                 ClearFlag(eMRF_MoveTarget);
  500.                 SetFlag(eMRF_RemoveMoveTarget);
  501.         }
  502.  
  503.         void SetInflectionPoint(const Vec3& pos)
  504.         {
  505.                 m_inflectionPoint = pos;
  506.                 SetFlag(eMRF_InflectionPoint);
  507.                 ClearFlag(eMRF_RemoveInflectionPoint);
  508.         }
  509.  
  510.         void ClearInflectionPoint()
  511.         {
  512.                 ClearFlag(eMRF_InflectionPoint);
  513.                 SetFlag(eMRF_RemoveInflectionPoint);
  514.         }
  515.  
  516.         void SetContext(unsigned int context)
  517.         {
  518.                 m_context = context;
  519.                 SetFlag(eMRF_Context);
  520.                 ClearFlag(eMRF_RemoveContext);
  521.         }
  522.  
  523.         void ClearContext()
  524.         {
  525.                 ClearFlag(eMRF_Context);
  526.                 SetFlag(eMRF_RemoveContext);
  527.         }
  528.  
  529.         void SetDesiredBodyDirectionAtTarget(const Vec3& target)
  530.         {
  531.                 m_desiredBodyDirectionAtTarget = target;
  532.                 SetFlag(eMRF_DesiredBodyDirectionAtTarget);
  533.                 ClearFlag(eMRF_RemoveDesiredBodyDirectionAtTarget);
  534.         }
  535.  
  536.         void ClearDesiredBodyDirectionAtTarget()
  537.         {
  538.                 ClearFlag(eMRF_DesiredBodyDirectionAtTarget);
  539.                 SetFlag(eMRF_RemoveDesiredBodyDirectionAtTarget);
  540.         }
  541.  
  542.         void SetForcedNavigation(const Vec3& pos)
  543.         {
  544.                 m_forcedNavigation = pos;
  545.                 SetFlag(eMRF_ForcedNavigation);
  546.                 ClearFlag(eMRF_RemoveForcedNavigation);
  547.         }
  548.  
  549.         void ClearForcedNavigation()
  550.         {
  551.                 m_forcedNavigation = ZERO;
  552.                 ClearFlag(eMRF_ForcedNavigation);
  553.                 SetFlag(eMRF_RemoveForcedNavigation);
  554.         }
  555.  
  556.         bool HasForcedNavigation() const
  557.         {
  558.                 return CheckFlag(eMRF_ForcedNavigation);
  559.         }
  560.  
  561.         bool HasLookTarget() const
  562.         {
  563.                 return CheckFlag(eMRF_LookTarget);
  564.         }
  565.  
  566.         bool RemoveLookTarget() const
  567.         {
  568.                 return CheckFlag(eMRF_RemoveLookTarget);
  569.         }
  570.  
  571.         const Vec3& GetLookTarget() const
  572.         {
  573.                 CRY_ASSERT(HasLookTarget());
  574.                 return m_lookTarget;
  575.         }
  576.  
  577.         float GetLookImportance() const
  578.         {
  579.                 CRY_ASSERT(HasLookTarget());
  580.                 return m_lookImportance;
  581.         }
  582.  
  583.         bool HasAimTarget() const
  584.         {
  585.                 return CheckFlag(eMRF_AimTarget);
  586.         }
  587.  
  588.         bool RemoveAimTarget() const
  589.         {
  590.                 return CheckFlag(eMRF_RemoveAimTarget);
  591.         }
  592.  
  593.         const Vec3& GetAimTarget() const
  594.         {
  595.                 CRY_ASSERT(HasAimTarget());
  596.                 return m_aimTarget;
  597.         }
  598.  
  599.         bool HasBodyTarget() const
  600.         {
  601.                 return CheckFlag(eMRF_BodyTarget);
  602.         }
  603.  
  604.         bool RemoveBodyTarget() const
  605.         {
  606.                 return CheckFlag(eMRF_RemoveBodyTarget);
  607.         }
  608.  
  609.         const Vec3& GetBodyTarget() const
  610.         {
  611.                 CRY_ASSERT(HasBodyTarget());
  612.                 return m_bodyTarget;
  613.         }
  614.  
  615.         bool HasFireTarget() const
  616.         {
  617.                 return CheckFlag(eMRF_FireTarget);
  618.         }
  619.  
  620.         bool RemoveFireTarget() const
  621.         {
  622.                 return CheckFlag(eMRF_RemoveFireTarget);
  623.         }
  624.  
  625.         const Vec3& GetFireTarget() const
  626.         {
  627.                 CRY_ASSERT(HasFireTarget());
  628.                 return m_fireTarget;
  629.         }
  630.  
  631.         bool HasDesiredSpeed() const
  632.         {
  633.                 return CheckFlag(eMRF_DesiredSpeed);
  634.         }
  635.  
  636.         bool RemoveDesiredSpeed() const
  637.         {
  638.                 return CheckFlag(eMRF_RemoveDesiredSpeed);
  639.         }
  640.  
  641.         float GetDesiredSpeed() const
  642.         {
  643.                 CRY_ASSERT(HasDesiredSpeed());
  644.                 return m_desiredSpeed;
  645.         }
  646.  
  647.         float GetDesiredTargetSpeed() const
  648.         {
  649.                 CRY_ASSERT(HasDesiredSpeed());
  650.                 return m_targetSpeed;
  651.         }
  652.  
  653.         bool HasPseudoSpeed() const
  654.         {
  655.                 return CheckFlag(eMRF_PseudoSpeed);
  656.         }
  657.  
  658.         bool RemovePseudoSpeed() const
  659.         {
  660.                 return CheckFlag(eMRF_RemovePseudoSpeed);
  661.         }
  662.  
  663.         bool HasPrediction() const
  664.         {
  665.                 return CheckFlag(eMRF_Prediction);
  666.         }
  667.  
  668.         bool RemovePrediction() const
  669.         {
  670.                 return CheckFlag(eMRF_RemovePrediction);
  671.         }
  672.  
  673.         float GetPseudoSpeed() const
  674.         {
  675.                 CRY_ASSERT(HasPseudoSpeed());
  676.                 return m_pseudoSpeed;
  677.         }
  678.  
  679.         bool ShouldJump() const
  680.         {
  681.                 return CheckFlag(eMRF_Jump);
  682.         }
  683.  
  684.         bool HasStance() const
  685.         {
  686.                 return CheckFlag(eMRF_Stance);
  687.         }
  688.  
  689.         bool RemoveStance() const
  690.         {
  691.                 return CheckFlag(eMRF_RemoveStance);
  692.         }
  693.  
  694.         EStance GetStance() const
  695.         {
  696.                 CRY_ASSERT(HasStance());
  697.                 return m_stance;
  698.         }
  699.  
  700.         bool HasMoveTarget() const
  701.         {
  702.                 return CheckFlag(eMRF_MoveTarget);
  703.         }
  704.  
  705.         bool RemoveMoveTarget() const
  706.         {
  707.                 return CheckFlag(eMRF_RemoveMoveTarget);
  708.         }
  709.  
  710.         const Vec3& GetMoveTarget() const
  711.         {
  712.                 CRY_ASSERT(HasMoveTarget());
  713.                 return m_moveTarget;
  714.         }
  715.  
  716.         bool HasInflectionPoint() const
  717.         {
  718.                 return CheckFlag(eMRF_InflectionPoint);
  719.         }
  720.  
  721.         bool RemoveInflectionPoint() const
  722.         {
  723.                 return CheckFlag(eMRF_RemoveInflectionPoint);
  724.         }
  725.  
  726.         const Vec3& GetInflectionPoint() const
  727.         {
  728.                 CRY_ASSERT(HasInflectionPoint());
  729.                 return m_inflectionPoint;
  730.         }
  731.  
  732.         bool HasDesiredBodyDirectionAtTarget() const
  733.         {
  734.                 return CheckFlag(eMRF_DesiredBodyDirectionAtTarget);
  735.         }
  736.  
  737.         bool RemoveDesiredBodyDirectionAtTarget() const
  738.         {
  739.                 return CheckFlag(eMRF_RemoveDesiredBodyDirectionAtTarget);
  740.         }
  741.  
  742.         const Vec3& GetDesiredBodyDirectionAtTarget() const
  743.         {
  744.                 assert(HasDesiredBodyDirectionAtTarget());
  745.                 return m_desiredBodyDirectionAtTarget;
  746.         }
  747.  
  748.         bool HasContext() const
  749.         {
  750.                 return CheckFlag(eMRF_Context);
  751.         }
  752.  
  753.         bool RemoveContext() const
  754.         {
  755.                 return CheckFlag(eMRF_RemoveContext);
  756.         }
  757.  
  758.         const unsigned int GetContext() const
  759.         {
  760.                 CRY_ASSERT(HasContext());
  761.                 return m_context;
  762.         }
  763.  
  764.         const Vec3& GetForcedNavigation() const
  765.         {
  766.                 CRY_ASSERT(HasForcedNavigation());
  767.                 return m_forcedNavigation;
  768.         }
  769.  
  770.         ILINE float GetDistanceToPathEnd() const
  771.         {
  772.                 return m_distanceToPathEnd;
  773.         }
  774.  
  775.         ILINE const Vec3& GetDirOffFromPath() const
  776.         {
  777.                 return m_dirOffFromPath;
  778.         }
  779.  
  780.         void SetNoAiming()
  781.         {
  782.                 SetFlag(eMRF_NoAiming);
  783.         }
  784.  
  785.         bool HasNoAiming() const
  786.         {
  787.                 return CheckFlag(eMRF_NoAiming);
  788.         }
  789.  
  790.         bool HasDeltaMovement() const
  791.         {
  792.                 return CheckFlag(eMRF_DeltaMovement);
  793.         }
  794.  
  795.         const Vec3& GetDeltaMovement() const
  796.         {
  797.                 CRY_ASSERT(HasDeltaMovement());
  798.                 return m_deltaMovement;
  799.         }
  800.  
  801.         bool HasDeltaRotation() const
  802.         {
  803.                 return CheckFlag(eMRF_DeltaRotation);
  804.         }
  805.  
  806.         const Ang3& GetDeltaRotation() const
  807.         {
  808.                 CRY_ASSERT(HasDeltaRotation());
  809.                 return m_deltaRotation;
  810.         }
  811.  
  812.         bool HasLean() const
  813.         {
  814.                 return CheckFlag(eMRF_DesiredLean);
  815.         }
  816.  
  817.         float GetLean() const
  818.         {
  819.                 CRY_ASSERT(HasLean());
  820.                 return m_desiredLean;
  821.         }
  822.  
  823.         bool RemoveLean() const
  824.         {
  825.                 return CheckFlag(eMRF_RemoveDesiredLean);
  826.         }
  827.  
  828.         bool HasPeekOver() const
  829.         {
  830.                 return CheckFlag(eMRF_DesiredPeekOver);
  831.         }
  832.  
  833.         float GetPeekOver() const
  834.         {
  835.                 CRY_ASSERT(HasPeekOver());
  836.                 return m_desiredPeekOver;
  837.         }
  838.  
  839.         bool RemovePeekOver() const
  840.         {
  841.                 return CheckFlag(eMRF_RemoveDesiredPeekOver);
  842.         }
  843.  
  844.         bool RemoveActorTarget() const
  845.         {
  846.                 return CheckFlag(eMRF_RemoveActorTarget);
  847.         }
  848.  
  849.         bool HasActorTarget() const
  850.         {
  851.                 return CheckFlag(eMRF_ActorTarget);
  852.         }
  853.  
  854.         const SActorTargetParams& GetActorTarget() const
  855.         {
  856.                 CRY_ASSERT(CheckFlag(eMRF_ActorTarget));
  857.                 return m_actorTarget;
  858.         }
  859.  
  860.         void SetMannequinTagRequest(const SMannequinTagRequest& mannequinTagRequest)
  861.         {
  862.                 m_mannequinTagRequest = mannequinTagRequest;
  863.         }
  864.  
  865.         const SMannequinTagRequest& GetMannequinTagRequest() const
  866.         {
  867.                 return m_mannequinTagRequest;
  868.         }
  869.  
  870.         void ClearMannequinTagRequest()
  871.         {
  872.                 m_mannequinTagRequest.Clear();
  873.         }
  874.  
  875.         void SetAICoverRequest(const SAICoverRequest& aiCoverRequest)
  876.         {
  877.                 m_aiCoverRequest = aiCoverRequest;
  878.         }
  879.  
  880.         const SAICoverRequest& GetAICoverRequest() const
  881.         {
  882.                 return m_aiCoverRequest;
  883.         }
  884.  
  885.         void ClearAICoverRequest()
  886.         {
  887.                 m_aiCoverRequest = SAICoverRequest();
  888.         }
  889.  
  890. private:
  891.  
  892.         // M谩rcio: Changed this from an enum since some compilers don't support 64bit enums
  893.         // and we had ran out of bits!
  894.         typedef uint64 MovementRequestFlags;
  895.  
  896.         // do we have some parameter
  897.         static const uint64 eMRF_LookTarget = 1ULL << 0;
  898.         static const uint64 eMRF_AimTarget = 1ULL << 1;
  899.         static const uint64 eMRF_DesiredSpeed = 1ULL << 2;
  900.         static const uint64 eMRF_Stance = 1ULL << 3;
  901.         static const uint64 eMRF_MoveTarget = 1ULL << 4;
  902.         static const uint64 eMRF_DeltaMovement = 1ULL << 5;
  903.         static const uint64 eMRF_DeltaRotation = 1ULL << 6;
  904.         static const uint64 eMRF_LookStyle = 1ULL << 7;
  905.         static const uint64 eMRF_DesiredLean = 1ULL << 8;
  906.         static const uint64 eMRF_DesiredPeekOver = 1ULL << 9;
  907.         static const uint64 eMRF_ActorTarget = 1ULL << 10;
  908.         static const uint64 eMRF_FireTarget = 1ULL << 11;
  909.         static const uint64 eMRF_PseudoSpeed = 1ULL << 12;
  910.         static const uint64 eMRF_Prediction = 1ULL << 13;
  911.         static const uint64 eMRF_ForcedNavigation = 1ULL << 14;
  912.         static const uint64 eMRF_BodyTarget = 1ULL << 15;
  913.         static const uint64 eMRF_InflectionPoint = 1ULL << 16;
  914.         static const uint64 eMRF_Context = 1ULL << 17;
  915.         static const uint64 eMRF_DesiredBodyDirectionAtTarget = 1ULL << 18;
  916.  
  917.         // other flags
  918.         static const uint64 eMRF_Jump = 1ULL << 19;
  919.         static const uint64 eMRF_NoAiming = 1ULL << 20;
  920.         static const uint64 eMRF_AllowStrafing = 1ULL << 21;
  921.         static const uint64 eMRF_DirectionOffPath = 1ULL << 22;
  922.         static const uint64 eMRF_AllowLowerBodyToTurn = 1ULL << 23;
  923.         static const uint64 eMRF_BodyOrientationMode = 1ULL << 24;
  924.  
  925.         // remove parameter
  926.         static const uint64 eMRF_RemoveLookTarget = eMRF_LookTarget << 31;
  927.         static const uint64 eMRF_RemoveAimTarget = eMRF_AimTarget << 31;
  928.         static const uint64 eMRF_RemoveDesiredSpeed = eMRF_DesiredSpeed << 31;
  929.         static const uint64 eMRF_RemoveStance = eMRF_Stance << 31;
  930.         static const uint64 eMRF_RemoveMoveTarget = eMRF_MoveTarget << 31;
  931.         static const uint64 eMRF_RemoveDesiredLean = eMRF_DesiredLean << 31;
  932.         static const uint64 eMRF_RemoveDesiredPeekOver = eMRF_DesiredPeekOver << 31;
  933.         static const uint64 eMRF_RemoveActorTarget = eMRF_ActorTarget << 31;
  934.         static const uint64 eMRF_RemoveFireTarget = eMRF_FireTarget << 31;
  935.         static const uint64 eMRF_RemovePseudoSpeed = eMRF_PseudoSpeed << 31;
  936.         static const uint64 eMRF_RemovePrediction = eMRF_Prediction << 31;
  937.         static const uint64 eMRF_RemoveForcedNavigation = eMRF_ForcedNavigation << 31;
  938.         static const uint64 eMRF_RemoveBodyTarget = eMRF_BodyTarget << 31;
  939.         static const uint64 eMRF_RemoveInflectionPoint = eMRF_InflectionPoint << 31;
  940.         static const uint64 eMRF_RemoveContext = eMRF_Context << 31;
  941.         static const uint64 eMRF_RemoveDesiredBodyDirectionAtTarget = eMRF_DesiredBodyDirectionAtTarget << 31;
  942.         static const uint64 eMRF_RemoveBodyOrientationMode = eMRF_BodyOrientationMode << 31;
  943.  
  944.         ILINE void ClearFlag(MovementRequestFlags flag)
  945.         {
  946.                 m_flags &= ~flag;
  947.         }
  948.         ILINE void SetFlag(MovementRequestFlags flag)
  949.         {
  950.                 m_flags |= flag;
  951.         }
  952.         ILINE bool CheckFlag(MovementRequestFlags flag) const
  953.         {
  954.                 return (m_flags & flag) != 0;
  955.         }
  956.  
  957.         uint64                    m_flags;
  958.         Vec3                      m_lookTarget;
  959.         Vec3                      m_aimTarget;
  960.         Vec3                      m_bodyTarget;
  961.         Vec3                      m_fireTarget;
  962.         float                     m_desiredSpeed;
  963.         float                     m_targetSpeed;
  964.         float                     m_lookImportance;
  965.         float                     m_distanceToPathEnd;
  966.         Vec3                      m_dirOffFromPath;
  967.         EStance                   m_stance;
  968.         Vec3                      m_moveTarget;
  969.         Vec3                      m_inflectionPoint; // Estimated position of the next move target after reaching the current move target
  970.         Vec3                      m_desiredBodyDirectionAtTarget;
  971.         Vec3                      m_deltaMovement;
  972.         Ang3                      m_deltaRotation;
  973.         float                     m_desiredLean;
  974.         float                     m_desiredPeekOver;
  975.         SActorTargetParams        m_actorTarget;
  976.         int                       m_alertness;
  977.         int                       m_alertnessLast;
  978.         float                     m_pseudoSpeed;
  979.         SPredictedCharacterStates m_prediction;
  980.         Vec3                      m_forcedNavigation;
  981.         ELookStyle                m_eLookStyle;
  982.         unsigned int              m_context;
  983.         SMannequinTagRequest      m_mannequinTagRequest;
  984.         SAICoverRequest           m_aiCoverRequest;
  985.         EBodyOrientationMode      m_bodyOrientationMode;
  986. };
  987.  
  988. struct SStanceState
  989. {
  990.         SStanceState() :
  991.                 pos(ZERO),
  992.                 entityDirection(FORWARD_DIRECTION),
  993.                 animationBodyDirection(FORWARD_DIRECTION),
  994.                 upDirection(0, 0, 1),
  995.                 weaponPosition(ZERO),
  996.                 aimDirection(FORWARD_DIRECTION),
  997.                 fireDirection(FORWARD_DIRECTION),
  998.                 eyePosition(ZERO),
  999.                 eyeDirection(FORWARD_DIRECTION),
  1000.                 lean(0.0f),
  1001.                 peekOver(0.0f),
  1002.                 m_StanceSize(Vec3Constants<float>::fVec3_Zero, Vec3Constants<float>::fVec3_Zero),
  1003.                 m_ColliderSize(Vec3Constants<float>::fVec3_Zero, Vec3Constants<float>::fVec3_Zero)
  1004.         {
  1005.         }
  1006.  
  1007.         // Note: All positions a directions are in worldspace.
  1008.         Vec3  pos;                    // Position of the character.
  1009.         Vec3  entityDirection;
  1010.         Vec3  animationBodyDirection;
  1011.         Vec3  upDirection;            // Up direction of the character.
  1012.         Vec3  weaponPosition;         // Game logic position of the weapon of the character.
  1013.         Vec3  aimDirection;           // Direction from the weapon position to aim target, used for representation.
  1014.         Vec3  fireDirection;          // Direction from the weapon position to the fire target, used for emitting the bullets.
  1015.         Vec3  eyePosition;            // Game logic position of the eye of the character.
  1016.         Vec3  eyeDirection;           // Direction from the eye position to the lookat or aim-at target.
  1017.         float lean;                   // The amount the character is leaning -1 = left, 1 = right;
  1018.         float peekOver;               // The amount the character is peeking over 0 = none, 1 = max;
  1019.         AABB  m_StanceSize;           // Game logic bounds of the character related to the 'pos'.
  1020.         AABB  m_ColliderSize;         // The size of only the collider in this stance.
  1021. };
  1022.  
  1023. struct SMovementState : public SStanceState
  1024. {
  1025.         SMovementState() :
  1026.                 SStanceState(),
  1027.                 fireTarget(ZERO),
  1028.                 stance(STANCE_NULL),
  1029.                 animationEyeDirection(FORWARD_DIRECTION),
  1030.                 movementDirection(ZERO),
  1031.                 lastMovementDirection(ZERO),
  1032.                 desiredSpeed(0.0f),
  1033.                 minSpeed(0.2f),
  1034.                 normalSpeed(1.0f),
  1035.                 maxSpeed(2.0f),
  1036.                 slopeAngle(0.0f),
  1037.                 atMoveTarget(false),
  1038.                 isAlive(true),
  1039.                 isAiming(false),
  1040.                 isFiring(false),
  1041.                 isVisible(false),
  1042.                 isMoving(false)
  1043.         {
  1044.         }
  1045.  
  1046.         Vec3    fireTarget;            // Target position to fire at, note the direction from weapon to the fire target
  1047.                                        // can be different than aim direction. This value is un-smoothed target set by AI.
  1048.         EStance stance;                // Stance of the character.
  1049.         Vec3    animationEyeDirection; // Eye direction reported from Animation [used for cinematic look-ats]
  1050.         Vec3    movementDirection, lastMovementDirection;
  1051.         float   desiredSpeed;
  1052.         float   minSpeed;
  1053.         float   normalSpeed;
  1054.         float   maxSpeed;
  1055.         float   slopeAngle; // Degrees of ground below character (positive when facing uphill, negative when facing downhill).
  1056.         bool    atMoveTarget;
  1057.         bool    isAlive;
  1058.         bool    isAiming;
  1059.         bool    isFiring;
  1060.         bool    isVisible;
  1061.         bool    isMoving;
  1062. };
  1063.  
  1064. struct SStanceStateQuery
  1065. {
  1066.         SStanceStateQuery(const Vec3& pos, const Vec3& trg, EStance _stance, float _lean = 0.0f, float _peekOver = 0.0f, bool _defaultPose = false)
  1067.                 : stance(_stance)
  1068.                 , lean(_lean)
  1069.                 , peekOver(_peekOver)
  1070.                 , defaultPose(_defaultPose)
  1071.                 , position(pos)
  1072.                 , target(trg)
  1073.         {
  1074.         }
  1075.  
  1076.         SStanceStateQuery(EStance _stance, float _lean = 0.0f, float _peekOver = 0.0f, bool _defaultPose = false)
  1077.                 : stance(_stance)
  1078.                 , lean(_lean)
  1079.                 , peekOver(_peekOver)
  1080.                 , defaultPose(_defaultPose)
  1081.                 , position(ZERO)
  1082.                 , target(ZERO)
  1083.         {
  1084.         }
  1085.  
  1086.         SStanceStateQuery()
  1087.                 : stance(STANCE_NULL)
  1088.                 , lean(0.0f)
  1089.                 , peekOver(0.0f)
  1090.                 , defaultPose(true)
  1091.                 , position(ZERO)
  1092.                 , target(ZERO)
  1093.         {
  1094.         }
  1095.  
  1096.         EStance stance;
  1097.         float   lean;
  1098.         float   peekOver;
  1099.         bool    defaultPose;
  1100.         Vec3    position;
  1101.         Vec3    target;
  1102. };
  1103.  
  1104. struct IMovementController
  1105. {
  1106.         virtual ~IMovementController(){}
  1107.         // Description:
  1108.         //    Request some movement;
  1109.         //    If the request cannot be fulfilled, returns false, and request
  1110.         //    is updated to be a similar request that could be fulfilled
  1111.         //    (calling code is then free to inspect this, and call RequestMovement
  1112.         //    again to set a new movement)
  1113.         virtual bool RequestMovement(CMovementRequest& request) = 0;
  1114.         // Description:
  1115.         //    Fetch the current movement state of the entity
  1116.         virtual void GetMovementState(SMovementState& state) = 0;
  1117.         // Description:
  1118.         //    Returns the description of the stance as if the specified stance would be set right now.
  1119.         //              If the parameter 'defaultPose' is set to false, the current aim and look target info is used to
  1120.         //              calculate the stance info, else a default pose facing along positive Y-axis is returned.
  1121.         //              Returns false if the description cannot be queried.
  1122.         virtual bool        GetStanceState(const SStanceStateQuery& query, SStanceState& state) = 0;
  1123.  
  1124.         virtual inline Vec2 GetDesiredMoveDir() const                                                         { return Vec2(0, 1); }
  1125.  
  1126.         virtual void        SetExactPositioningListener(IExactPositioningListener* pExactPositioningListener) {}
  1127.  
  1128.         // Note: this will not return an exactpositioning target if the request is still pending
  1129.         virtual const SExactPositioningTarget* GetExactPositioningTarget() { return NULL; }
  1130. };
  1131.  
  1132. #endif
  1133.  
downloadIMovementController.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