BVB Source Codes

CRYENGINE Show Puppet.h Source code

Return Download CRYENGINE: download Puppet.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef PUPPET_H
  4. #define PUPPET_H
  5.  
  6. #if _MSC_VER > 1000
  7.         #pragma once
  8. #endif // _MSC_VER > 1000
  9.  
  10. #include "PipeUser.h"
  11. #include "PathObstacles.h"
  12. #include "ValueHistory.h"
  13. #include <CryAISystem/IPerceptionHandler.h>
  14. #include <CryAISystem/IVisionMap.h>
  15. #include "PostureManager.h"
  16.  
  17. // forward declarations
  18. class CPersonalInterestManager;
  19. class CFireCommandGrenade;
  20. struct PendingDeathReaction;
  21.  
  22. //      Path finder blockers types.
  23. enum ENavigationBlockers
  24. {
  25.         PFB_NONE,
  26.         PFB_ATT_TARGET,
  27.         PFB_REF_POINT,
  28.         PFB_BEACON,
  29.         PFB_DEAD_BODIES,
  30.         PFB_EXPLOSIVES,
  31.         PFB_PLAYER,
  32.         PFB_BETWEEN_NAV_TARGET,
  33. };
  34.  
  35. // Quick prototype of a signal/state container
  36. class CSignalState
  37. {
  38. public:
  39.         bool bState;
  40.         bool bLastUpdatedState;
  41.         CSignalState() : bState(false), bLastUpdatedState(false) {}
  42.         bool CheckUpdate()
  43.         {
  44.                 bool bRet = bState != bLastUpdatedState;
  45.                 bLastUpdatedState = bState;
  46.                 return bRet;
  47.         }
  48. };
  49.  
  50. struct CSpeedControl
  51. {
  52.         float      fPrevDistance;
  53.         CTimeValue fLastTime;
  54.         Vec3       vLastPos;
  55.         //      CAIPIDController PIDController;
  56.         //      static const float      m_CMaxDist;
  57.  
  58.         CSpeedControl() : vLastPos(0.0f, 0.0f, 0.0f), fPrevDistance(0.0f){}
  59.         void Reset(const Vec3 vPos, CTimeValue fTime)
  60.         {
  61.                 fPrevDistance = 0;
  62.                 fLastTime = fTime;
  63.                 vLastPos = vPos;
  64.         }
  65. };
  66.  
  67. typedef std::multimap<float, SHideSpot>                    MultimapRangeHideSpots;
  68. typedef std::map<CWeakRef<CAIObject>, float>               DevaluedMap;
  69. typedef std::map<CWeakRef<CAIObject>, CWeakRef<CAIObject>> ObjectObjectMap;
  70.  
  71. struct SShootingStatus
  72. {
  73.         bool      triggerPressed;             // True if the weapon trigger is being pressed.
  74.         float     timeSinceTriggerPressed;    // Time in seconds since last time trigger is pressed.
  75.         bool      friendOnWay;                // True if the fire if blocked by friendly unit.
  76.         float     friendOnWayElapsedTime;     // Time in seconds the line of fire is blocked by friendly unit.
  77.         EFireMode fireMode;                   // Fire mode status, see EFireMode.
  78. };
  79.  
  80. struct SSoundPerceptionDescriptor
  81. {
  82.         float fMinDist;         // Minimum distance from sound origin to recognize it
  83.         float fRadiusScale;     // Scalar value applied to radius to amplify or reduce the effect of the sound
  84.         float fSoundTime;       // How long to remember the sound
  85.         float fBaseThreat;      // Base threat value
  86.         float fLinStepMin;      // Linear step ranges used based on ratio of distance to sound and sound radius
  87.         float fLinStepMax;
  88.  
  89.         SSoundPerceptionDescriptor(float _fMinDist = 0.0f, float _fRadiusScale = 1.0f, float _fSoundTime = 0.0f, float _fBaseThreat = 0.0f, float _fLinStepMin = 0.0f, float _fLinStepMax = 1.0f)
  90.         {
  91.                 Set(_fMinDist, _fRadiusScale, _fSoundTime, _fBaseThreat, _fLinStepMin, _fLinStepMax);
  92.         }
  93.         void Set(float _fMinDist = 0.0f, float _fRadiusScale = 1.0f, float _fSoundTime = 0.0f, float _fBaseThreat = 0.0f, float _fLinStepMin = 0.0f, float _fLinStepMax = 1.0f)
  94.         {
  95.                 fMinDist = _fMinDist;
  96.                 fRadiusScale = _fRadiusScale;
  97.                 fSoundTime = _fSoundTime;
  98.                 fBaseThreat = _fBaseThreat;
  99.                 fLinStepMin = _fLinStepMin;
  100.                 fLinStepMax = _fLinStepMax;
  101.         }
  102. };
  103.  
  104. struct SSortedHideSpot
  105. {
  106.         SSortedHideSpot(float weight, SHideSpot* pHideSpot) : weight(weight), pHideSpot(pHideSpot) {}
  107.         inline bool operator<(const SSortedHideSpot& rhs) const { return weight > rhs.weight; } // highest weight first.
  108.         float      weight;
  109.         SHideSpot* pHideSpot;
  110. };
  111.  
  112. class CPuppet
  113.         : public CPipeUser
  114.           , public IPuppet
  115. {
  116.         friend class CAISystem;
  117. public:
  118.         CPuppet();
  119.         virtual ~CPuppet();
  120.  
  121.         static void                  ClearStaticData();
  122.  
  123.         virtual const IPuppet*       CastToIPuppet() const { return this; }
  124.         virtual IPuppet*             CastToIPuppet()       { return this; }
  125.  
  126.         inline PostureManager&       GetPostureManager()   { return m_postureManager; };
  127.  
  128.         virtual void                 ResetPerception();
  129.  
  130.         virtual bool                 CanDamageTarget(IAIObject* target = 0) const;
  131.         virtual bool                 CanDamageTargetWithMelee() const;
  132.  
  133.         void                         AdjustSpeed(CAIObject* pNavTarget, float distance = 0);
  134.         void                         ResetSpeedControl();
  135.         virtual bool                 GetValidPositionNearby(const Vec3& proposedPosition, Vec3& adjustedPosition) const;
  136.         virtual bool                 GetTeleportPosition(Vec3& teleportPos) const;
  137.         virtual bool                 GetPosAlongPath(float dist, bool extrapolateBeyond, Vec3& retPos) const;
  138.         virtual IFireCommandHandler* GetFirecommandHandler() const                 { return m_pFireCmdHandler; }
  139.  
  140.         void                         SetAllowedToHitTarget(bool state)             { m_allowedToHitTarget = state; }
  141.         bool                         IsAllowedToHitTarget() const                  { return m_allowedToHitTarget; }
  142.  
  143.         void                         SetAllowedToUseExpensiveAccessory(bool state) { m_allowedToUseExpensiveAccessory = state; }
  144.         bool                         IsAllowedToUseExpensiveAccessory() const      { return m_allowedToUseExpensiveAccessory; }
  145.  
  146.         // Returns the AI object to shoot at.
  147.         CAIObject* GetFireTargetObject() const;
  148.  
  149.         // Returns the reaction time of between allowed to fire and allowed to damage target.
  150.         float GetFiringReactionTime(const Vec3& targetPos) const;
  151.  
  152.         // Returns true if the reaction time pas passed.
  153.         float GetCurrentFiringReactionTime() const { return m_firingReactionTime; }
  154.         bool  HasFiringReactionTimePassed() const  { return m_firingReactionTimePassed; }
  155.  
  156.         // Returns the current status shooting related parameters.
  157.         void GetShootingStatus(SShootingStatus& ss);
  158.  
  159.         // Sets the allowed start and end of the path strafing distance.
  160.         void SetAllowedStrafeDistances(float start, float end, bool whileMoving);
  161.  
  162.         // Sets the allowed start and end of the path strafing distance.
  163.         void SetAdaptiveMovementUrgency(float minUrgency, float maxUrgency, float scaleDownPathlen);
  164.  
  165.         // Sets the stance that will be used when the character starts to move.
  166.         void SetDelayedStance(int stance);
  167.  
  168.         void AdjustMovementUrgency(float& urgency, float pathLength, float* maxPathLen = 0);
  169.  
  170.         /// Returns all the path obstacles that might affect paths. If allowRecalc = false then the cached obstacles
  171.         /// will not be updated
  172.         const CPathObstacles& GetPathAdjustmentObstacles(bool allowRecalc = true) { if (allowRecalc) CalculatePathObstacles(); return m_pathAdjustmentObstacles; }
  173.         const CPathObstacles& GetLastPathAdjustmentObstacles() const              { return m_pathAdjustmentObstacles; }
  174.  
  175.         // current accuracy (with soft cover and motion correction, distance/stance, ....)
  176.         float GetAccuracy(const CAIObject* pTarget) const;
  177.  
  178.         /// inherited
  179.         virtual DamagePartVector* GetDamageParts();
  180.  
  181.         // Returns the memory usage of the object.
  182.         size_t MemStats();
  183.  
  184.         // Inherited from IPuppet
  185.         virtual void       UpTargetPriority(const IAIObject* pTarget, float fPriorityIncrement);
  186.         virtual void       UpdateBeacon();
  187.         virtual IAIObject* MakeMeLeader();
  188.         virtual bool       CheckFriendsInLineOfFire(const Vec3& fireDir, bool cheapTest);
  189.  
  190.         // Modify perception descriptions for visual and sound stimulus
  191.         bool               GetSoundPerceptionDescriptor(EAISoundStimType eType, SSoundPerceptionDescriptor& sDescriptor) const;
  192.         bool               SetSoundPerceptionDescriptor(EAISoundStimType eType, const SSoundPerceptionDescriptor& sDescriptor);
  193.  
  194.         virtual IAIObject* GetEventOwner(IAIObject* pObject) const;
  195.         virtual CAIObject* GetEventOwner(CWeakRef<CAIObject> refOwned) const;
  196.  
  197.         // trace from weapon pos to target body/eye,
  198.         // returns true if good to shoot
  199.         // in:  pTarget
  200.         //                      lowDamage       - low accuracy, should hit arms/legs if possible
  201.         // out: vTargetPos, vTargetDir, distance
  202.         bool         CheckAndGetFireTarget_Deprecated(IAIObject* pTarget, bool lowDamage, Vec3& vTargetPos, Vec3& vTargetDir) const;
  203.         virtual Vec3 ChooseMissPoint_Deprecated(const Vec3& targetPos) const;
  204.  
  205.         // Inherited from IPipeUser
  206.         virtual void Update(EObjectUpdate type);
  207.         virtual void UpdateProxy(EObjectUpdate type);
  208.         virtual void Devalue(IAIObject* pObject, bool bDevaluePuppets, float fAmount = 20.f);
  209.         virtual bool IsDevalued(IAIObject* pObject);
  210.         virtual void ClearDevalued();
  211.  
  212.         // Inherited from IAIObject
  213.         virtual void SetParameters(const AgentParameters& sParams);
  214.         virtual void Event(unsigned short eType, SAIEVENT* pEvent);
  215.         virtual void ParseParameters(const AIObjectParams& params, bool bParseMovementParams = true);
  216.         virtual bool CreateFormation(const char* szName, Vec3 vTargetPos);
  217.         virtual void Serialize(TSerialize ser);
  218.         virtual void PostSerialize();
  219.         virtual void SetPFBlockerRadius(int blockerType, float radius);
  220.  
  221.         // Inherited from CAIObject
  222.         virtual void OnObjectRemoved(CAIObject* pObject);
  223.         virtual void Reset(EObjectResetType type);
  224.         virtual void GetPathAgentNavigationBlockers(NavigationBlockers& navigationBlockers, const struct PathfindRequest* pRequest);
  225.  
  226.         // <title GetDistanceAlongPath>
  227.         // Description: returns the distance of a point along the puppet's path
  228.         // Arguments:
  229.         // Vec3& pos: point
  230.         // bool bInit: if true, the current path is stored in a internal container; if false, the distance is computed
  231.         //              along the stored path, no matter if the current path is different
  232.         // Returns:
  233.         // distance of point along Puppets path; distance value would be negative if the point is ahead along the path
  234.         virtual float GetDistanceAlongPath(const Vec3& pos, bool bInit);
  235.  
  236.         bool          GetPotentialTargets(PotentialTargetMap& targetMap) const;
  237.  
  238.         uint32        GetBestTargets(tAIObjectID* targets, uint32 maxCount) const;
  239.  
  240.         bool          AddAggressiveTarget(IAIObject* pTarget);
  241.         bool          SetTempTargetPriority(ETempTargetPriority priority);
  242.         bool          UpdateTempTarget(const Vec3& vPosition);
  243.         bool          ClearTempTarget();
  244.         bool          DropTarget(IAIObject* pTarget);
  245.  
  246.         virtual void  SetRODHandler(IAIRateOfDeathHandler* pHandler);
  247.         virtual void  ClearRODHandler();
  248.  
  249.         virtual bool  GetPerceivedTargetPos(IAIObject* pTarget, Vec3& vPos) const;
  250.  
  251.         virtual void  UpdateLookTarget(CAIObject* pTarget);
  252.         virtual void  UpdateLookTarget3D(CAIObject* pTarget);
  253.         virtual bool  NavigateAroundObjects(const Vec3& targetPos, bool fullUpdate);
  254.  
  255.         void          SetForcedNavigation(const Vec3& vDirection, float fSpeed);
  256.         void          ClearForcedNavigation();
  257.  
  258.         void          SetVehicleStickTarget(EntityId targetId) { m_vehicleStickTarget = targetId; }
  259.         EntityId      GetVehicleStickTarget() const            { return m_vehicleStickTarget; }
  260.  
  261.         /// Like NavigateAroundObjects but navigates around an individual AI obstacle (implemented by the puppet/vehicle).
  262.         /// If steer is true then navigation should be done by steering. If false then navigation should be
  263.         /// done by slowing down/stopping.
  264.         virtual bool NavigateAroundAIObject(const Vec3& targetPos, const CAIObject* obstacle, const Vec3& predMyPos, const Vec3& predObjectPos, bool steer, bool in3D);
  265.  
  266.         // Change flag so this puppet can be shoot or not
  267.         virtual void SetCanBeShot(bool bCanBeShot);
  268.         virtual bool GetCanBeShot() const;
  269.  
  270.         // Change flag so this puppet can fire at its memory target always
  271.         virtual void            SetMemoryFireType(EMemoryFireType eType);
  272.         virtual EMemoryFireType GetMemoryFireType() const;
  273.         virtual bool            CanMemoryFire() const;
  274.  
  275.         // Check if can fire at my target from this given stance
  276.         bool CanFireInStance(EStance stance, float fDistanceRatio = 0.9f) const;
  277.  
  278.         // Request secondary grenade fire (no interruption to fire mode)
  279.         // iRegType - Who to throw at (See AI_REG_*)
  280.         void RequestThrowGrenade(ERequestedGrenadeType eGrenadeType, int iRegType);
  281.  
  282.         // Returns the current alertness level of the puppet.
  283.         inline int                       GetAlertness() const { return m_Alertness; }
  284.  
  285.         virtual void                     CheckCloseContact(IAIObject* pTarget, float fDistSq);
  286.  
  287.         virtual float                    AdjustTargetVisibleRange(const CAIActor& observer, float fVisibleRange) const;
  288.  
  289.         inline EPuppetUpdatePriority     GetUpdatePriority() const                    { return m_updatePriority; }
  290.         inline void                      SetUpdatePriority(EPuppetUpdatePriority pri) { m_updatePriority = pri; }
  291.  
  292.         const AIWeaponDescriptor&        QueryCurrentWeaponDescriptor(bool bIsSecondaryFire = false, ERequestedGrenadeType prefGrenadeType = eRGT_ANY);
  293.         inline const AIWeaponDescriptor& GetCurrentWeaponDescriptor() const { return m_CurrentWeaponDescriptor; }
  294.  
  295.         // Returns true if it is possible to aim at the target without colliding with a wall etc in front of the puppet.
  296.         bool         CanAimWithoutObstruction(const Vec3& vTargetPos);
  297.         bool         CheckLineOfFire(const Vec3& vTargetPos, float fDistance, float fSoftDistance, EStance stance = STANCE_NULL) const;
  298.  
  299.         float        GetTimeToNextShot() const;
  300.  
  301.         virtual void MakeIgnorant(bool bIgnorant) { m_bCanReceiveSignals = !bIgnorant; }
  302.  
  303.         // Perception handler modifiers
  304.         // [AlexMcC|26.04.10]: These won't work with CTargetTrackManager
  305.         bool AddPerceptionHandlerModifier(IPerceptionHandlerModifier* pModifier);
  306.         bool RemovePerceptionHandlerModifier(IPerceptionHandlerModifier* pModifier);
  307.         bool GetPerceptionHandlerModifiers(TPerceptionHandlerModifiersVector& outModifiers);
  308.         // Debug draw for perception handler modifiers
  309.         void DebugDrawPerceptionHandlerModifiers();
  310.  
  311.         IFireCommandHandler* m_pFireCmdHandler;
  312.         CFireCommandGrenade* m_pFireCmdGrenade;
  313.  
  314.         float                m_targetApproach;
  315.         float                m_targetFlee;
  316.         bool                 m_targetApproaching;
  317.         bool                 m_targetFleeing;
  318.         bool                 m_lastTargetValid;
  319.         Vec3                 m_lastTargetPos;
  320.         float                m_lastTargetSpeed;
  321.         CSignalState         m_attTargetOutOfTerritory;
  322.  
  323.         bool                 m_bCanReceiveSignals;
  324.  
  325. protected:
  326.         typedef enum
  327.         {
  328.                 PA_NONE = 0,
  329.                 PA_LOOKING,
  330.                 PA_STICKING
  331.         } TPlayerActionType;
  332.  
  333.         struct STargetSelectionInfo
  334.         {
  335.                 CWeakRef<CAIObject> bestTarget;
  336.                 EAITargetThreat     targetThreat;
  337.                 EAITargetType       targetType;
  338.                 SAIPotentialTarget* pTargetInfo;
  339.                 bool                bCurrentTargetErased;
  340.                 bool                bIsGroupTarget;
  341.  
  342.                 STargetSelectionInfo() : targetThreat(AITHREAT_NONE), targetType(AITARGET_NONE), pTargetInfo(),
  343.                         bCurrentTargetErased(false), bIsGroupTarget(false) {}
  344.         };
  345.  
  346.         void                CheckAwarenessPlayer(); // check if the player is sticking or looking at me
  347.  
  348.         SAIPotentialTarget* AddEvent(CWeakRef<CAIObject> refObject, SAIPotentialTarget& ed);
  349.         //      float CalculatePriority(CAIObject * pTarget);
  350.  
  351.         void UpdatePuppetInternalState();
  352.         bool UpdateTargetSelection(STargetSelectionInfo& targetSelectionInfo);
  353.         bool GetTargetTrackBestTarget(CWeakRef<CAIObject>& refBestTarget, SAIPotentialTarget*& pTargetInfo,
  354.                                       bool& bCurrentTargetErased) const;
  355.  
  356.         void         HandleSoundEvent(SAIEVENT* pEvent);
  357.         void         HandlePathDecision(MNMPathRequestResult& result);
  358.         void         HandleVisualStimulus(SAIEVENT* pEvent);
  359.         virtual void HandleBulletRain(SAIEVENT* pEvent);
  360.  
  361.         //      float GetEventPriority(const CAIObject *pObj,const EventData &ed) const;
  362.         void UpdateAlertness();
  363.         void ResetAlertness();
  364.  
  365.         // Steers the puppet around the object and makes it avoid the immediate obstacles. Returns true if steering is
  366.         // being done
  367.         bool            SteerAroundVehicle(const Vec3& targetPos, const CAIObject* object, const Vec3& predMyPos, const Vec3& predObjectPos);
  368.         bool            SteerAroundPuppet(const Vec3& targetPos, const CAIObject* object, const Vec3& predMyPos, const Vec3& predObjectPos);
  369.         bool            SteerAround3D(const Vec3& targetPos, const CAIObject* object, const Vec3& predMyPos, const Vec3& predObjectPos);
  370.         /// Helper for NavigateAroundObjects
  371.         bool            NavigateAroundObjectsInternal(const Vec3& targetPos, const Vec3& myPos, bool in3D, const CAIObject* object);
  372.         /// Helper for NavigateAroundObjects
  373.         ENavInteraction NavigateAroundObjectsBasicCheck(const CAIObject* object) const;
  374.         bool            NavigateAroundObjectsBasicCheck(const Vec3& targetPos, const Vec3& myPos, bool in3D, const CAIObject* object, float extraDist);
  375.  
  376.         // helper to judge what type of fire command we are using
  377.         bool IsSecondaryFireCommand() const { return m_fireMode == FIREMODE_SECONDARY || m_fireMode == FIREMODE_SECONDARY_SMOKE; }
  378.         bool IsMeleeFireCommand() const     { return m_fireMode == FIREMODE_MELEE || m_fireMode == FIREMODE_MELEE_FORCED; }
  379.  
  380.         // decides whether to fire or not
  381.         void FireCommand(float updateTime);
  382.         // process secondary fire
  383.         void FireSecondary(CAIObject* pTarget, ERequestedGrenadeType prefGrenadeType = eRGT_ANY);
  384.         // process melee fire
  385.         void FireMelee(CAIObject* pTarget);
  386.  
  387.         bool CheckTargetInRange(Vec3& vTargetPos);
  388.  
  389.         /// Selects the best hide points from a list that should just contain accessible hidespots
  390.         Vec3 GetHidePoint(MultimapRangeHideSpots& hidespots, float fSearchDistance, const Vec3& hideFrom, int nMethod, bool bSameOk, float fMinDistance);
  391.  
  392.         // Evaluates whether the chosen navigation point will expose us too much to the target
  393.         bool Compromising(const Vec3& pos, const Vec3& dir, const Vec3& hideFrom, const Vec3& objectPos, const Vec3& searchPos, bool bIndoor, bool bCheckVisibility) const;
  394.  
  395.         void RegisterTargetAwareness(float amount);
  396.  
  397.         void UpdateTargetMovementState();
  398.  
  399.         bool IsFriendInLineOfFire(CAIObject* pFriend, const Vec3& firePos, const Vec3& fireDirection, bool cheapTest);
  400.  
  401.         void AdjustWithPrediction(CAIObject* pTarget, Vec3& posOut);
  402.  
  403.         // Returns true if it pActor is obstructing aim.
  404.         bool                      ActorObstructingAim(const CAIActor* pActor, const Vec3& firePos, const Vec3& dir, const Ray& fireRay) const;
  405.  
  406.         void                      CreatePendingDeathReaction(int groupID, PendingDeathReaction* pPendingDeathReaction) const;
  407.  
  408.         CPersonalInterestManager* GetPersonalInterestManager();
  409.  
  410.         CTimeValue        m_fLastUpdateTime;
  411.  
  412.         bool              m_bDryUpdate;
  413.  
  414.         DevaluedMap       m_mapDevaluedPoints;
  415.  
  416.         int               m_Alertness;
  417.  
  418.         float             m_fLastTimeAwareOfPlayer;
  419.         TPlayerActionType m_playerAwarenessType;
  420.  
  421.         bool              m_allowedToHitTarget;
  422.         bool              m_allowedToUseExpensiveAccessory;
  423.         bool              m_firingReactionTimePassed;
  424.         float             m_firingReactionTime;
  425.         float             m_outOfAmmoTimeOut;
  426.  
  427.         bool              m_bWarningTargetDistance;
  428.  
  429.         CSpeedControl     m_SpeedControl;
  430.  
  431.         // for smoothing the output of AdjustSpeed
  432.         float                m_chaseSpeed;
  433.         float                m_chaseSpeedRate;
  434.         int                  m_lastChaseUrgencyDist;
  435.         int                  m_lastChaseUrgencySpeed;
  436.  
  437.         CWeakRef<CAIVehicle> m_refAvoidedVehicle;
  438.         CTimeValue           m_vehicleAvoidingTime;
  439.  
  440.         Vec3                 m_vForcedNavigation;
  441.         float                m_fForcedNavigationSpeed;
  442.  
  443.         EntityId             m_vehicleStickTarget;
  444.  
  445.         // map blocker_type-radius
  446.         typedef std::map<int, float> TMapBlockers;
  447.         TMapBlockers m_PFBlockers;
  448.  
  449.         // Current actor weapon descriptor
  450.         EntityId           m_currentWeaponId;
  451.         AIWeaponDescriptor m_CurrentWeaponDescriptor;
  452.  
  453.         //request throw grenade data
  454.         bool                  m_bGrenadeThrowRequested;
  455.         ERequestedGrenadeType m_eGrenadeThrowRequestType;
  456.         int                   m_iGrenadeThrowTargetType;
  457.  
  458.         float                 m_allowedStrafeDistanceStart; // Allowed strafe distance at the start of the path
  459.         float                 m_allowedStrafeDistanceEnd;   // Allowed strafe distance at the end of the path
  460.         bool                  m_allowStrafeLookWhileMoving; // Allow strafing when moving along path.
  461.         bool                  m_closeRangeStrafing;
  462.  
  463.         float                 m_strafeStartDistance;
  464.  
  465.         float                 m_adaptiveUrgencyMin;
  466.         float                 m_adaptiveUrgencyMax;
  467.         float                 m_adaptiveUrgencyScaleDownPathLen;
  468.         float                 m_adaptiveUrgencyMaxPathLen;
  469.  
  470.         int                   m_delayedStance;
  471.         int                   m_delayedStanceMovementCounter;
  472.  
  473.         enum ESeeTargetFrom
  474.         {
  475.                 ST_HEAD,
  476.                 ST_WEAPON,
  477.                 ST_OFSETTED_LEFT,
  478.                 ST_OFSETTED_RIGHT,
  479.         };
  480.         float                  m_lastTimeSeeFromHead;
  481.  
  482.         float                  m_timeSinceTriggerPressed;
  483.         float                  m_friendOnWayElapsedTime;
  484.  
  485.         bool                   m_bCoverFireEnabled;
  486.  
  487.         bool                   m_bCanBeShot;
  488.  
  489.         EMemoryFireType        m_eMemoryFireType;
  490.  
  491.         DamagePartVector       m_damageParts;
  492.  
  493.         IPerceptionHandler*    m_pPerceptionHandler;
  494.         IAIRateOfDeathHandler* m_pRODHandler;
  495.  
  496.         typedef std::vector<Vec3> TPointList;
  497.         TPointList m_InitialPath;
  498.  
  499.         void UpdateHealthTracking();
  500.  
  501. public:
  502.  
  503.         void ResetTargetTracking();
  504.         Vec3 UpdateTargetTracking(CWeakRef<CAIObject> refTarget, const Vec3& vTargetPos);
  505.         void UpdateFireReactionTimer(const Vec3& vTargetPos);
  506.         void UpdateTargetZone(CWeakRef<CAIObject> refTarget);
  507.  
  508. protected:
  509.  
  510.         struct LineOfFireState
  511.         {
  512.                 LineOfFireState()
  513.                         : asyncState(AsyncReady)
  514.                         , rayID(0)
  515.                         , result(false)
  516.                         , softDistance(0.0f)
  517.                 {
  518.                 }
  519.  
  520.                 ~LineOfFireState()
  521.                 {
  522.                         if (rayID)
  523.                                 gAIEnv.pRayCaster->Cancel(rayID);
  524.                 }
  525.  
  526.                 void Swap(LineOfFireState& other)
  527.                 {
  528.                         std::swap(asyncState, other.asyncState);
  529.                         std::swap(rayID, other.rayID);
  530.                         std::swap(softDistance, other.softDistance);
  531.                         std::swap(result, other.result);
  532.                 }
  533.  
  534.                 AsyncState  asyncState;
  535.                 QueuedRayID rayID;
  536.                 float       softDistance;
  537.                 bool        result;
  538.         };
  539.  
  540.         mutable LineOfFireState m_lineOfFireState;
  541.         void LineOfFireRayComplete(const QueuedRayID& rayID, const RayCastResult& result);
  542.  
  543.         struct ValidTargetState
  544.         {
  545.                 ValidTargetState()
  546.                         : asyncState(AsyncReady)
  547.                         , rayID(0)
  548.                         , latestHitDist(FLT_MAX)
  549.                 {
  550.                 }
  551.  
  552.                 ~ValidTargetState()
  553.                 {
  554.                         if (rayID)
  555.                                 gAIEnv.pRayCaster->Cancel(rayID);
  556.                 }
  557.  
  558.                 void Swap(ValidTargetState& other)
  559.                 {
  560.                         std::swap(asyncState, other.asyncState);
  561.                         std::swap(rayID, other.rayID);
  562.                         std::swap(latestHitDist, other.latestHitDist);
  563.                 }
  564.  
  565.                 AsyncState  asyncState;
  566.                 QueuedRayID rayID;
  567.                 float       latestHitDist;
  568.         };
  569.  
  570.         ValidTargetState m_validTargetState;
  571.         void FireTargetValidRayComplete(const QueuedRayID& rayID, const RayCastResult& result);
  572.         void QueueFireTargetValidRay(const CAIObject* targetObj, const Vec3& firePos, const Vec3& fireDir);
  573.  
  574. public:
  575.  
  576.         bool AdjustFireTarget(CAIObject* targetObject, const Vec3& target, bool hit, float missExtraOffset,
  577.                               float clampAngle, Vec3* posOut);
  578.         bool CalculateHitPointOnTarget(CAIObject* targetObject, const Vec3& target, float clampAngle, Vec3* posOut);
  579.         bool CalculateMissPointOutsideTargetSilhouette(CAIObject* targetObject, const Vec3& target, float missExtraOffset,
  580.                                                        Vec3* posOut);
  581.  
  582.         bool  IsFireTargetValid(const Vec3& pos, const CAIObject* pTargetObject);
  583.         float GetCoverFireTime() const;
  584.         float GetBurstFireDistanceScale() const;
  585.  
  586.         float GetTargetAliveTime();
  587.  
  588.         Vec3  InterpolateLookOrAimTargetPos(const Vec3& current, const Vec3& target, float maxRate);
  589.  
  590.         void  HandleBurstFireInit();
  591.         void  HandleWeaponEffectBurstDrawFire(CAIObject* pTarget, Vec3& aimTarget, bool& canFire);
  592.         void  HandleWeaponEffectBurstSnipe(CAIObject* pTarget, Vec3& aimTarget, bool& canFire);
  593.         void  HandleWeaponEffectPanicSpread(CAIObject* pTarget, Vec3& aimTarget, bool& canFire);
  594.         void  HandleWeaponEffectAimSweep(CAIObject* pTarget, Vec3& aimTarget, bool& canFire);
  595.  
  596.         struct STargetSilhouette
  597.         {
  598.                 STargetSilhouette()
  599.                 {
  600.                         Reset();
  601.                         baseMtx.SetIdentity();
  602.                 }
  603.  
  604.                 bool              valid;
  605.                 std::vector<Vec3> points;
  606.                 Matrix33          baseMtx;
  607.                 Vec3              center;
  608.  
  609.                 inline Vec3       ProjectVectorOnSilhouette(const Vec3& vec)
  610.                 {
  611.                         return Vec3(baseMtx.GetColumn0().Dot(vec), baseMtx.GetColumn2().Dot(vec), 0.0f);
  612.                 }
  613.  
  614.                 inline Vec3 IntersectSilhouettePlane(const Vec3& from, const Vec3& to)
  615.                 {
  616.                         if (!valid)
  617.                                 return to;
  618.  
  619.                         // Intersect (infinite) segment with the silhouette plane.
  620.                         Vec3 pn = baseMtx.GetColumn1();
  621.                         float pd = -pn.Dot(center);
  622.                         Vec3 dir = to - from;
  623.  
  624.                         float d = pn.Dot(dir);
  625.                         if (fabsf(d) < 1e-6)
  626.                                 return to;
  627.  
  628.                         float n = pn.Dot(from) + pd;
  629.                         return from + dir * (-n / d);
  630.                 }
  631.  
  632.                 void Reset()
  633.                 {
  634.                         valid = false;
  635.                         points.clear();
  636.                         center.zero();
  637.                 }
  638.         };
  639.  
  640.         STargetSilhouette     m_targetSilhouette;
  641.         Vec3                  m_targetLastMissPoint;
  642.         Vec3                  m_targetPosOnSilhouettePlane;
  643.         Vec3                  m_targetBiasDirection;
  644.         float                 m_targetFocus;
  645.         EAITargetZone         m_targetZone;
  646.         float                 m_targetDistanceToSilhouette;
  647.         float                 m_targetEscapeLastMiss;
  648.         float                 m_targetSeenTime;
  649.         float                 m_targetLostTime;
  650.         float                 m_targetDazzlingTime;
  651.         float                 m_burstEffectTime;
  652.         int                   m_burstEffectState;
  653.  
  654.         size_t                m_lastMissShotsCount;
  655.         size_t                m_lastHitShotsCount;
  656.         size_t                m_lastTargetPart;
  657.         float                 m_targetDamageHealthThr;
  658.  
  659.         bool                  m_lastAimObstructionResult;
  660.         EPuppetUpdatePriority m_updatePriority;
  661.  
  662.         PostureManager        m_postureManager;
  663.  
  664.         CTimeValue            m_lastTimeUpdatedBestTarget;
  665.  
  666.         /// It's quite expensive to walk through all AI objects and find which ones to steer
  667.         /// around so they get cached here and only set on full updates
  668.         std::vector<const CAIObject*> m_steeringObjects;
  669.         CTimeValue                    m_lastSteerTime;
  670.  
  671.         CAIRadialOccypancy            m_steeringOccupancy;
  672.         float                         m_steeringOccupancyBias;
  673.         bool                          m_steeringEnabled;
  674.         float                         m_steeringAdjustTime;
  675.         float                         m_fLastNavTest;
  676.  
  677.         CValueHistory<float>*         m_targetDamageHealthThrHistory;
  678.  
  679.         CWeakRef<CAIVehicle> GetAvoidedVehicle() { return m_refAvoidedVehicle; }
  680.         inline int64         GetVehicleAvoidingTime()
  681.         {
  682.                 return (GetAISystem()->GetFrameStartTime() - m_vehicleAvoidingTime).GetMilliSecondsAsInt64();
  683.         }
  684.  
  685.         virtual void EnableFire(bool enable);
  686.         virtual bool IsFireEnabled() const;
  687.  
  688.         inline void  EnableCoverFire(bool enable) { m_bCoverFireEnabled = enable; }
  689.         inline bool  IsCoverFireEnabled() const   { return m_bCoverFireEnabled; }
  690.  
  691.         inline void  SetAvoidedVehicle(CWeakRef<CAIVehicle> refVehicle)
  692.         {
  693.                 if (!refVehicle.IsValid())
  694.                 {
  695.                         CCCPOINT(CPuppet_SetAvoidedVehicle_Reset);
  696.                         refVehicle.Reset();
  697.                         m_vehicleAvoidingTime = 0.0f;
  698.                 }
  699.                 else
  700.                 {
  701.                         CCCPOINT(CPuppet_SetAvoidedVehicle_Set)
  702.                         m_refAvoidedVehicle = refVehicle;
  703.                         m_vehicleAvoidingTime = GetAISystem()->GetFrameStartTime();
  704.                 }
  705.         }
  706.  
  707.         // Updates the strafing logic.
  708.         void UpdateStrafing();
  709.  
  710.         // The fire target cache caches raycast results used for
  711.         // testing if a
  712.         class SAIFireTargetCache
  713.         {
  714.         public:
  715.                 // cppcheck-suppress uninitMemberVar
  716.                 SAIFireTargetCache() : m_size(0), m_head(0), m_queries(0), m_hits(0) {}
  717.  
  718.                 float QueryCachedResult(const Vec3& pos, const Vec3& dir, float reqDist)
  719.                 {
  720.                         m_queries++;
  721.                         const float distThr = sqr(0.15f);
  722.                         const float angleThr = cosf(DEG2RAD(6.0f));
  723.                         int j = m_head;
  724.                         for (int i = 0; i < m_size; ++i)
  725.                         {
  726.                                 j--;
  727.                                 if (j < 0) j = CACHE_SIZE - 1;
  728.  
  729.                                 if ((m_cacheReqDist[j] - 0.5f) >= reqDist &&
  730.                                     Distance::Point_PointSq(pos, m_cachePos[j]) < distThr &&
  731.                                     m_cacheDir[j].Dot(dir) > angleThr)
  732.                                 {
  733.                                         m_hits++;
  734.                                         return m_cacheDist[j];
  735.                                 }
  736.                         }
  737.                         // Could not find.
  738.                         return -1.0f;
  739.                 }
  740.  
  741.                 void Insert(const Vec3& pos, const Vec3& dir, float reqDist, float dist)
  742.                 {
  743.                         m_cachePos[m_head] = pos;
  744.                         m_cacheDir[m_head] = dir;
  745.                         m_cacheDist[m_head] = dist;
  746.                         m_cacheReqDist[m_head] = reqDist;
  747.                         if (m_size < CACHE_SIZE)
  748.                                 m_size++;
  749.                         m_head++;
  750.                         if (m_head >= CACHE_SIZE)
  751.                                 m_head = 0;
  752.                 }
  753.  
  754.                 int  GetQueries() const { return m_queries; }
  755.                 int  GetHits() const    { return m_hits; }
  756.  
  757.                 void Reset()
  758.                 {
  759.                         m_size = 0;
  760.                         m_head = 0;
  761.                         m_hits = 0;
  762.                         m_queries = 0;
  763.                 }
  764.  
  765.         private:
  766.                 static const int CACHE_SIZE = 8;
  767.                 Vec3             m_cachePos[CACHE_SIZE];
  768.                 Vec3             m_cacheDir[CACHE_SIZE];
  769.                 float            m_cacheReqDist[CACHE_SIZE];
  770.                 float            m_cacheDist[CACHE_SIZE];
  771.                 int              m_size, m_head;
  772.                 int              m_hits;
  773.                 int              m_queries;
  774.         };
  775.  
  776.         inline void SetAlarmed()
  777.         {
  778.                 AgentPerceptionParameters& perceptionParameters = m_Parameters.m_PerceptionParams;
  779.                 m_alarmedTime = perceptionParameters.forgetfulnessTarget + perceptionParameters.forgetfulnessMemory;
  780.  
  781.                 // reset perceptionScale to 1.0f when alerted
  782.                 AgentPerceptionParameters::SPerceptionScale& perceptionScale = perceptionParameters.perceptionScale;
  783.                 perceptionScale.visual = 1.0f;
  784.                 perceptionScale.audio = 1.0f;
  785.  
  786.                 gEnv->pAISystem->DisableGlobalPerceptionScaling();
  787.         }
  788.         virtual bool  IsAlarmed() const               { return m_alarmedTime > 0.01f; }
  789.         virtual float GetPerceptionAlarmLevel() const { return max(GetParameters().m_PerceptionParams.minAlarmLevel, m_alarmedLevel); }
  790.  
  791.         float m_alarmedTime;
  792.         float m_alarmedLevel;
  793.         bool  m_damagePartsUpdated;
  794.  
  795.         uint8 m_fireDisabled;
  796.  
  797.         // Perception descriptors
  798.         DynArray<SSoundPerceptionDescriptor>         m_SoundPerceptionDescriptor;
  799.         static SSoundPerceptionDescriptor            s_DefaultSoundPerceptionDescriptor[AISOUND_LAST];
  800.  
  801.         static std::vector<Vec3>                     s_projectedPoints;
  802.         static std::vector<std::pair<float, size_t>> s_weights;
  803.         static std::vector<CAIActor*>                s_enemies;
  804.         static std::vector<SSortedHideSpot>          s_sortedHideSpots;
  805.         static MultimapRangeHideSpots                s_hidespots;
  806.         static MapConstNodesDistance                 s_traversedNodes;
  807. };
  808.  
  809. ILINE const CPuppet* CastToCPuppetSafe(const IAIObject* pAI) { return pAI ? pAI->CastToCPuppet() : 0; }
  810. ILINE CPuppet*       CastToCPuppetSafe(IAIObject* pAI)       { return pAI ? pAI->CastToCPuppet() : 0; }
  811. float                SquaredDistance(const CPuppet& puppetA, const CPuppet& puppetB);
  812.  
  813. #endif
  814.  
downloadPuppet.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