SCR_AICombatMoveLogic_Attack.c

Go to the documentation of this file.

/*
This analyzes combat move state and issues new requests for combat move tree.
*/
 
class SCR_AICombatMoveLogic_Attack : AITaskScripted
{
    // Inputs
    protected static const string PORT_BASE_TARGET = "BaseTarget";
    
    protected SCR_AICombatMoveState m_State;
    protected SCR_AIUtilityComponent m_Utility;
    protected SCR_AICombatComponent m_CombatComp;
    protected IEntity m_MyEntity;
    protected CharacterControllerComponent m_CharacterController;
    
    // Values updated on each update, to avoid passing them through calls
    protected EAIThreatState m_eThreatState;
    protected ECharacterStance m_eStance;
    protected EWeaponType m_eWeaponType;
    protected BaseTarget m_Target;
    protected float m_fTargetDist;
    protected float m_fWeaponMinDist;
    protected bool m_bCloseRangeCombat; // True if we consider it's a close range fight
    
    protected float m_fNextUpdate_ms;
    [Attribute("500")]
    protected float m_fUpdateInterval_ms;
    
    // Half-angle of cover query sector when directed cover search is used
    protected const float COVER_QUERY_SECTOR_ANGLE_RAD = 0.3 * Math.PI;
    
    //--------------------------------------------------------------------------------------------
    protected override void OnInit(AIAgent owner)
    {
        m_Utility = SCR_AIUtilityComponent.Cast(owner.FindComponent(SCR_AIUtilityComponent));
        if (m_Utility)
            m_State = m_Utility.m_CombatMoveState;
        
        m_MyEntity = owner.GetControlledEntity();
        
        if (m_MyEntity)
        {
            m_CharacterController = CharacterControllerComponent.Cast(m_MyEntity.FindComponent(CharacterControllerComponent));
            m_CombatComp = SCR_AICombatComponent.Cast(m_MyEntity.FindComponent(SCR_AICombatComponent));
        }
    }
    
    protected override ENodeResult EOnTaskSimulate(AIAgent owner, float dt)
    {
        float currentTime_ms = GetGame().GetWorld().GetWorldTime();
        if (currentTime_ms < m_fNextUpdate_ms)
            return ENodeResult.RUNNING;
        m_fNextUpdate_ms = currentTime_ms + m_fUpdateInterval_ms;
        
        BaseTarget target;
        GetVariableIn(PORT_BASE_TARGET, target);
        if (!target || !target.GetTargetEntity() || !m_State || !m_MyEntity || !m_Utility || !m_CombatComp || !m_CharacterController)
            return ENodeResult.FAIL;
        
        // Don't run combat movement logic if CombatMove BT is not used now (like in turret)
        SCR_AIBehaviorBase executedBehavior = SCR_AIBehaviorBase.Cast(m_Utility.GetExecutedAction());
        if (executedBehavior && !executedBehavior.m_bUseCombatMove)
            return ENodeResult.RUNNING;
        
        // Update cached variables
        m_Target = target;
        m_fTargetDist = target.GetDistance();
        m_bCloseRangeCombat = m_fTargetDist < SCR_AICombatMoveUtils.CLOSE_RANGE_COMBAT_DIST;
        m_eThreatState = m_Utility.m_ThreatSystem.GetState();
        m_eStance = m_CharacterController.GetStance();
        m_fWeaponMinDist = m_CombatComp.GetSelectedWeaponMinDist();
        m_eWeaponType = m_CombatComp.GetSelectedWeaponType();
        
        
        /*      
        //------------------------------------------------------------------------------------
        Combat movement logic
        
        Conditions represent states inside which we want to remain.
        
        Conditions are organized based on their priority, highest first.
        
        Within each state there can be extra logic which decides if it's worth to
        send a new request, because even though we have selected a state, we should avoid
        spamming same request over and over.
        
        Conditions for states mostly depend on Combat Move State and its timers.
        
        It is important to write logic in such a way that it doesn't depend on state
        of this node. In this case the state flow also doesn't depend on it, and AI
        does movement is more fluent when switching to a new behavior which also utilizes
        combat movement, including attacking a different target.
        */
        
        if (SuppressedInCoverCondition())
        {
            SuppressedInCoverLogic();
        }
        else if (MoveFromTargetCondition())
        {
            // Too close to target
            // Step away
            if (MoveFromTargetNewRequestCondition())
                PushRequestMoveFromTarget();
        }
        else if (CurrentCoverUselessCondition())
        {
            // Current cover has been compromised, it's not directed at enemy any more
            // Find a new cover nearby
            PushRequestLeaveUselessCover();
        }
        else if (m_State.m_bInCover && m_CharacterController.IsReloading())
        {
            // We're reloading and can't do much else now
            // Hide in cover
            if (m_State.m_bExposedInCover)
                m_State.ApplyRequestChangeStanceInCover(false);
        }
        else if (m_State.m_bInCover && !m_State.m_bExposedInCover)
        {
            // We're in cover but we are still hiding in it, unhide
            m_State.ApplyRequestChangeStanceInCover(true);
        }
        else if (FFAvoidanceCondition())
        {
            if (FFAvoidanceNewRequestCondition())
                PushRequestFFAvoidance();
        }
        else if (MoveToNextPosCondition())
        {
            // We've waited here too long, move to next place
            PushRequestMove();
        }
        else if (!m_State.IsExecutingRequest() && !m_State.m_bInCover)
        {
            // We are stopped and not in cover, manage our stance
            ECharacterStance newStance = ResolveStanceOutsideCover(m_bCloseRangeCombat, m_eThreatState);
            if (newStance > m_eStance)
            {
                // Only let stance go down, no need to get back up
                m_State.ApplyRequestChangeStanceOutsideCover(newStance);
            }
        }
        
        return ENodeResult.RUNNING;
    }
    
    
    //--------------------------------------------------------------------------------------------
    // Friendly fire avoidance
    
    // Friendly fire avoidance condition
    protected bool FFAvoidanceCondition()
    {
        // Should we deal with friendly fire avoidance?
        
        // Ignore if we don't want to aim at all
        if (!m_State.m_bAimAtTarget)
            return false;
        
        // True only when not in cover
        if (m_State.m_bInCover)
            return false;
        
        // True when not moving to cover
        if (m_State.IsMovingToCover())
            return false;
        
        // True when friendly is in aim
        return m_Utility.m_CombatComponent.IsFriendlyInAim();
    }
    
    // Friendly fire avoidance condition for pushing new request
    protected bool FFAvoidanceNewRequestCondition()
    {
        if (!m_State.IsExecutingRequest())
            return true;
        
        // Still executing ...
        // Send new request only if we are executing NOT side-step
        SCR_AICombatMoveRequest_Move rq = SCR_AICombatMoveRequest_Move.Cast(m_State.GetRequest());
        if (!rq)
            return true;
        
        return rq.m_eReason != SCR_EAICombatMoveReason.FF_AVOIDANCE;
    }
    
    protected void PushRequestFFAvoidance()
    {
        SCR_AICombatMoveRequest_Move rq = new SCR_AICombatMoveRequest_Move();
        
        rq.m_eReason = SCR_EAICombatMoveReason.FF_AVOIDANCE;
        
        // If prev. request was FF avoidance too, keep direction.
        // Otherwise choose a new direction.
        SCR_AICombatMoveRequest_Move prevRequest = SCR_AICombatMoveRequest_Move.Cast(m_State.GetRequest());
        if (prevRequest && prevRequest.m_eReason == SCR_EAICombatMoveReason.FF_AVOIDANCE)
        {
            rq.m_eDirection = prevRequest.m_eDirection;
        }
        else
        {
            if (Math.RandomIntInclusive(0, 1) == 1)
                rq.m_eDirection = SCR_EAICombatMoveDirection.RIGHT;
            else
                rq.m_eDirection = SCR_EAICombatMoveDirection.LEFT;
        }
        
        rq.m_eStanceMoving = m_CharacterController.GetStance(); // Don't change stance
        rq.m_eStanceEnd = rq.m_eStanceMoving;
        rq.m_vMovePos = ResolveRequestTargetPos();
        rq.m_eMovementType = EMovementType.WALK;
        rq.m_fMoveDistance = 1.5;
        rq.m_bAimAtTarget = SCR_AICombatMoveUtils.IsAimingAndMovementPossible(rq.m_eStanceMoving, rq.m_eMovementType);
        rq.m_bAimAtTargetEnd = true;
        
        m_State.ApplyNewRequest(rq);
    }
    
    
    //--------------------------------------------------------------------------------------------
    // Movement
    
    protected bool MoveToNextPosCondition()
    {
        // Don't get any more closer
        // Except we should still move closer if we haven't seen target for a long time
        float optimalDist = ResolveOptimalDistance(m_fWeaponMinDist);
        if (m_fTargetDist < optimalDist && m_Target.GetTimeSinceSeen() < 15)
            return false;
            
        if (m_State.IsExecutingRequest())
            return false;
        
        // If it's first run, ignore timers, only if:
        // - If we are not in cover.
        if (IsFirstExecution() && !m_State.m_bInCover)
            return true;
        
        float stoppedWaitTime = ResolveStoppedWaitTime(m_State.m_bInCover, m_eThreatState, m_eWeaponType);  
        return m_State.m_fTimerStopped_s > stoppedWaitTime;
    }
    
    protected void PushRequestMove()
    {       
        SCR_AICombatMoveRequest_Move rq = new SCR_AICombatMoveRequest_Move();
        
        rq.m_eReason = SCR_EAICombatMoveReason.STANDARD;
        
        // Common values
        rq.m_vTargetPos = ResolveRequestTargetPos();
        ResolveMoveRequestMovePosAndDir(rq.m_vTargetPos, rq.m_vMovePos, rq.m_eDirection, rq.m_fCoverSearchSectorHalfAngleRad);
        rq.m_bTryFindCover = true;
        rq.m_bUseCoverSearchDirectivity = true;
        rq.m_bCheckCoverVisibility = true;
 
        float coverSearchDistMin = 0;
        float coverSearchDistMax = 30;
        float moveDistanceMax = 30;
        if (m_bCloseRangeCombat)
        {
            // Close range combat
            
            switch (m_eThreatState)
            {
                case EAIThreatState.THREATENED:
                {
                    rq.m_eStanceMoving = ECharacterStance.CROUCH;
                    rq.m_eStanceEnd = ECharacterStance.CROUCH;
                    coverSearchDistMin = 2.0;
                    coverSearchDistMax = 10.0;
                    moveDistanceMax = 8.0;
                    break;
                }
                default:
                {
                    rq.m_eStanceMoving = ECharacterStance.STAND;
                    rq.m_eStanceEnd = ECharacterStance.CROUCH;
                    coverSearchDistMin = 5.0;
                    coverSearchDistMax = 15.0;
                    moveDistanceMax = 10.0;
                    break;
                }
            }
            
            rq.m_bFailIfNoCover = false;
            rq.m_eMovementType = EMovementType.RUN;
            rq.m_bAimAtTarget = SCR_AICombatMoveUtils.IsAimingAndMovementPossible(rq.m_eStanceMoving, rq.m_eMovementType) &&
                                IsAimingAndMovingAllowedForWeapon(m_eWeaponType);
            rq.m_bAimAtTargetEnd = true;
        }
        else
        {
            // Long range combat
            
            switch (m_eThreatState)
            {
                case EAIThreatState.THREATENED:
                {
                    coverSearchDistMin = 2.0;
                    coverSearchDistMax = 20.0;
                    moveDistanceMax = 10.0;
                    rq.m_eStanceMoving = ECharacterStance.CROUCH;
                    rq.m_eStanceEnd = ECharacterStance.PRONE;
                    break;
                }
                default:
                {
                    coverSearchDistMin = 10.0;
                    coverSearchDistMax = 30.0;
                    moveDistanceMax = 15.0; // Shouldn't be so large because we are sprinting and can't shoot
                    rq.m_eStanceMoving = ECharacterStance.CROUCH;
                    rq.m_eStanceEnd = ECharacterStance.CROUCH;
                    break;
                }
            }
            
            if (IsFirstExecution())
                rq.m_bFailIfNoCover = true; // On first run we want to move to cover, or stay where we are if there is no cover, and shoot.
            else
                rq.m_bFailIfNoCover = m_State.m_bInCover; // Don't leave cover if there is no next cover
            
            rq.m_eMovementType = EMovementType.SPRINT;
            rq.m_bAimAtTarget = false; // Can't aim at tgt while sprinting
            rq.m_bAimAtTargetEnd = true;
        }
        
        // If we are not in cover, min cover search distance is overridden to 0, we should find any cover ASAP
        if (!m_State.m_bInCover)
            coverSearchDistMin = 0;
        
        rq.m_fCoverSearchDistMin = coverSearchDistMin;
        rq.m_fCoverSearchDistMax = coverSearchDistMax;
        rq.m_fMoveDistance = Math.RandomFloat(0.5, 1.0) * moveDistanceMax; // Move distance if cover is not found, randomized
        
        // Subscribe to events
        // We will pronounce voice lines once we start or end moving
        rq.GetOnMovementStarted().Insert(OnMovementStarted);
        rq.GetOnCompleted().Insert(OnMovementCompleted);
        
        m_State.ApplyNewRequest(rq);
    }
    
    protected static void OnMovementStarted(SCR_AIUtilityComponent utility, SCR_AICombatMoveRequest_Move rq, vector pos, bool destinationIsCover)
    {
        if (!utility.m_CommsHandler.CanBypass())
        {
            SCR_AITalkRequest talkRq = new SCR_AITalkRequest(ECommunicationType.REPORT_MOVING, null, vector.Zero, 0, false, false, SCR_EAITalkRequestPreset.IRRELEVANT_IMMEDIATE);
            utility.m_CommsHandler.AddRequest(talkRq);
        }
    }
    
    protected static void OnMovementCompleted(SCR_AIUtilityComponent utility, SCR_AICombatMoveRequestBase rq)
    {
        if (!utility.m_CommsHandler.CanBypass())
        {
            SCR_AITalkRequest talkRq = new SCR_AITalkRequest(ECommunicationType.REPORT_COVERING, null, vector.Zero, 0, false, false, SCR_EAITalkRequestPreset.IRRELEVANT_IMMEDIATE);
            utility.m_CommsHandler.AddRequest(talkRq);
        }
    }
    
    // Resolves which move pos and dir. we should use for _MOVE_ request
    // By now rq.m_vTargetPos must be already calculated!
    protected void ResolveMoveRequestMovePosAndDir(vector targetPos, out vector outMovePos, out SCR_EAICombatMoveDirection outDirection, out float outCoverSearchSectorHalfAngleRad)
    {   
        AIWaypoint wp = null;
        AIAgent agent = m_Utility.GetAIAgent();
        AIGroup group = agent.GetParentGroup();
        if (group)
            wp = group.GetCurrentWaypoint();
        
        vector movePos;
        SCR_EAICombatMoveDirection eDirection;
        float coverSearchSectorHalfAngleRad;
        
        if (!wp)
        {
            // No waypoint, standard move logic
            movePos = targetPos;
            eDirection = SCR_EAICombatMoveDirection.FORWARD;
            
            if (IsFirstExecution())
                    coverSearchSectorHalfAngleRad = Math.PI; // Full circle, on first run we just want any cover if possible
                else
                    coverSearchSectorHalfAngleRad = COVER_QUERY_SECTOR_ANGLE_RAD;
        }
        else
        {
            vector wpPos = wp.GetOrigin();
            float wpRadius = wp.GetCompletionRadius();
            bool tgtInWaypoint = vector.DistanceXZ(wpPos, targetPos) < wpRadius;
            float myDistToWp = vector.DistanceXZ(wpPos, m_MyEntity.GetOrigin());
            
            if (myDistToWp > wpRadius)
            {
                // We are outside WP, move towards center
                movePos = wpPos;
                eDirection = SCR_EAICombatMoveDirection.CUSTOM_POS;
                coverSearchSectorHalfAngleRad = COVER_QUERY_SECTOR_ANGLE_RAD;
            }
            else if (myDistToWp > 0.5 * wpRadius)
            {
                // We are between 50% and 100% of wp radius
                
                if (tgtInWaypoint)
                {
                    // Towards target
                    movePos = targetPos;
                    eDirection = SCR_EAICombatMoveDirection.FORWARD;
                    coverSearchSectorHalfAngleRad = COVER_QUERY_SECTOR_ANGLE_RAD;
                }
                else
                {
                    // Move around current pos.
                    movePos = targetPos;
                    eDirection = SCR_EAICombatMoveDirection.ANYWHERE;
                    coverSearchSectorHalfAngleRad = -1.0;
                }
            }
            else
            {
                // We are within 50% radius of wp,
                // Move towards tgt, regardless where tgt is
                movePos = targetPos;
                eDirection = SCR_EAICombatMoveDirection.FORWARD;
                
                coverSearchSectorHalfAngleRad = COVER_QUERY_SECTOR_ANGLE_RAD;
            }
        }
        
        outMovePos = movePos;
        outDirection = eDirection;
        outCoverSearchSectorHalfAngleRad = coverSearchSectorHalfAngleRad;
    }
    
    //--------------------------------------------------------------------------------------------
    // Hide in cover when suppressed
    
    protected bool SuppressedInCoverCondition()
    {
        return m_State.m_bInCover && m_eThreatState == EAIThreatState.THREATENED;
    }
    
    protected void SuppressedInCoverLogic()
    {
        // We're pinned in cover and can't do much else now
        // Alternate hiding in cover and unhiding
        
        // How long to wait here? Depends on timer value from previous request.
        
        float waitTime_s;
        SCR_AICombatMoveRequestBase rq = m_State.GetRequest();
        if (SCR_AICombatMoveRequest_ChangeStanceInCover.Cast(rq) && rq.m_eReason == SCR_EAICombatMoveReason.SUPPRESSED_IN_COVER)
            waitTime_s = rq.m_f_UserTimer_s;
        else
        {
            if (m_State.m_bExposedInCover)
                waitTime_s = 1.7;
            else
                waitTime_s = 3.0;
        }
        
        if (m_State.m_bExposedInCover && m_State.m_fTimerRequest_s > waitTime_s)
        {
            float newWaitTime = Math.RandomFloat(3.5, 7.0); // Hide in cover for this time
            PushRequestChangeStanceInCover(false, SCR_EAICombatMoveReason.SUPPRESSED_IN_COVER, newWaitTime);
        }
        else if (!m_State.m_bExposedInCover && m_State.m_fTimerRequest_s > waitTime_s)
        {
            float newWaitTime = Math.RandomFloat(1.7, 2.5); // Expose out of cover for this time
            PushRequestChangeStanceInCover(true, SCR_EAICombatMoveReason.SUPPRESSED_IN_COVER, newWaitTime);
        }
    }
    
    protected void PushRequestChangeStanceInCover(bool exposed, SCR_EAICombatMoveReason reason, float waitTime)
    {
        SCR_AICombatMoveRequest_ChangeStanceInCover rq = new SCR_AICombatMoveRequest_ChangeStanceInCover();
        
        rq.m_bExposedInCover = exposed;
        rq.m_bAimAtTarget = true;
        rq.m_bAimAtTargetEnd = true;
        rq.m_f_UserTimer_s = waitTime;
        rq.m_eReason = reason;
        
        m_State.ApplyNewRequest(rq);
    }
    
    //--------------------------------------------------------------------------------------------
    // Cover not useful any more
    // It means that it doesn't provide cover in direction of enemy
    
    protected bool CurrentCoverUselessCondition()
    {
        if (!m_State.m_bInCover || !m_State.IsAssignedCoverValid())
            return false;
        
        vector tgtPos = m_Target.GetLastSeenPosition();
        
        float cosAngle = m_State.GetAssignedCover().CosAngleToThreat(tgtPos);
        return (cosAngle < 0.5); // cos 60 deg = 0.5
    }
    
    protected void PushRequestLeaveUselessCover()
    {
        SCR_AICombatMoveRequest_Move rq = new SCR_AICombatMoveRequest_Move();
        
        rq.m_eReason = SCR_EAICombatMoveReason.STANDARD;
        
        rq.m_vTargetPos = ResolveRequestTargetPos();
        rq.m_vMovePos = rq.m_vTargetPos;
        rq.m_bTryFindCover = true;
        rq.m_bUseCoverSearchDirectivity = true;
        rq.m_bCheckCoverVisibility = true;
        rq.m_bFailIfNoCover = true;
        rq.m_eStanceMoving = ECharacterStance.CROUCH;
        rq.m_eStanceEnd = ECharacterStance.CROUCH;
        rq.m_eMovementType = EMovementType.RUN;
        rq.m_eDirection = SCR_EAICombatMoveDirection.BACKWARD; // Move back from target
        rq.m_fCoverSearchSectorHalfAngleRad = -1.0;
        rq.m_bAimAtTarget = SCR_AICombatMoveUtils.IsAimingAndMovementPossible(rq.m_eStanceMoving, rq.m_eMovementType);
        rq.m_bAimAtTargetEnd = true;
        
        rq.m_fCoverSearchDistMin = 0;
        rq.m_fCoverSearchDistMax = 20;
        
        m_State.ApplyNewRequest(rq);
    }
    
    
    //--------------------------------------------------------------------------------------------
    // Moving away from target if we are too close
    // This is meant for very stepping backwards a very short distance
    
    protected bool MoveFromTargetCondition()
    {
        float weaponMinDist = Math.Max(3.0, m_fWeaponMinDist);
        
        return m_fTargetDist < weaponMinDist;
    }
    
    protected bool MoveFromTargetNewRequestCondition()
    {
        if (!m_State.IsExecutingRequest())
            return true;
        
        // Still executing ...
        // Send new request only if we are executing NOT side-step
        SCR_AICombatMoveRequest_Move rq = SCR_AICombatMoveRequest_Move.Cast(m_State.GetRequest());
        if (!rq)
            return true;
        
        return rq.m_eReason != SCR_EAICombatMoveReason.MOVE_FROM_TARGET;
    }
    
    protected void PushRequestMoveFromTarget()
    {
        SCR_AICombatMoveRequest_Move rq = new SCR_AICombatMoveRequest_Move();
        
        rq.m_eReason = SCR_EAICombatMoveReason.MOVE_FROM_TARGET;
        
        rq.m_vMovePos = ResolveRequestTargetPos();
        rq.m_eMovementType = EMovementType.RUN;
        rq.m_eStanceMoving = ECharacterStance.STAND;
        rq.m_eStanceEnd = ECharacterStance.STAND;
        rq.m_eDirection = SCR_EAICombatMoveDirection.BACKWARD;
        rq.m_fMoveDistance = 3.0;
        rq.m_bAimAtTarget = SCR_AICombatMoveUtils.IsAimingAndMovementPossible(rq.m_eStanceMoving, rq.m_eMovementType);
        rq.m_bAimAtTargetEnd = true;
        
        m_State.ApplyNewRequest(rq);
    }
    
    //--------------------------------------------------------------------------------------------
    protected vector ResolveRequestTargetPos()
    {
        if (m_CombatComp.IsTargetVisible(m_Target))
        {
            IEntity tgtEntity = m_Target.GetTargetEntity(); // We've checked above that it's not null
        
            ChimeraCharacter character = ChimeraCharacter.Cast(tgtEntity);
            if (character)
            {
                vector eyePos = character.EyePosition();
                return eyePos;
            }
            
            // It's a vehicle
            vector pos = tgtEntity.GetOrigin();
            pos = pos + Vector(0, 2.0, 0);
            return pos;
        }
        
        // Target is not visible, use last seen position
        vector lastSeenPos = m_Target.GetLastSeenPosition();
        lastSeenPos = lastSeenPos + Vector(0, 1.8, 0);
        return lastSeenPos;     
    }
    
    //--------------------------------------------------------------------------------------------
    protected float ResolveStoppedWaitTime(bool inCover, EAIThreatState threat, EWeaponType weaponType)
    {
        float waitTime;
        
        if (inCover)
        {
            // In cover
            switch (threat)
            {
                case EAIThreatState.THREATENED:
                    waitTime = 20.0;    // Stay in cover for a long time, until we are not suppressed any more
                    break;
                default:
                    waitTime = 5.0;
            }
        }
        else
        {
            // Not in cover
            switch (threat)
            {
                case EAIThreatState.THREATENED:
                    waitTime = 6.0;
                    break;
                default:
                    waitTime = 3.0;
                    break;
            }
        }
        
        // When using those weapons we want to move much less
        bool longWaitTime = false;
        switch (weaponType)
        {
            case EWeaponType.WT_MACHINEGUN:
            case EWeaponType.WT_ROCKETLAUNCHER:
            case EWeaponType.WT_GRENADELAUNCHER:
            case EWeaponType.WT_SNIPERRIFLE:
                longWaitTime = true;
        }
        
        if (longWaitTime)
            waitTime *= 2.0;
        
        return waitTime;
    }
    
    //--------------------------------------------------------------------------------------------
    // Returns stance when stopped outside cover
    protected static ECharacterStance ResolveStanceOutsideCover(bool closeRange, EAIThreatState threat)
    {
        if (closeRange)
        {
            // Close range combat
            return ECharacterStance.CROUCH;
        }
        else
        {
            // Long range combat
            switch (threat)
            {
                case EAIThreatState.THREATENED:
                    return ECharacterStance.PRONE;
                default:
                    return ECharacterStance.CROUCH;
            }
        }
        return ECharacterStance.STAND;
    }
    
    //--------------------------------------------------------------------------------------------
    // Returns 'optimal' distance
    // If we are between weaponMinDist and 'optimal' dist, we don't need to move closer to tgt
    protected static float ResolveOptimalDistance(float weaponMinDist)
    {
        return Math.Max(weaponMinDist + 5.0, 15.0);
    }
    
    //--------------------------------------------------------------------------------------------
    // Returns true if we are allowed to aim and move with that weapon
    protected static bool IsAimingAndMovingAllowedForWeapon(EWeaponType weaponType)
    {
        switch (weaponType)
        {
            // Most common case is fast
            case EWeaponType.WT_RIFLE:
                return true;
            
            case EWeaponType.WT_ROCKETLAUNCHER:
            case EWeaponType.WT_GRENADELAUNCHER:
                return false;
            
            // Everything else
            default:
                return true;
        }
        
        return true;
    }
    
    //--------------------------------------------------------------------------------------------
    // Returns true if it's first of combat movement logic. Doesn't mean first execution of this node.
    protected bool IsFirstExecution()
    {
        return !m_State.GetRequest();
    }
    
    //--------------------------------------------------------------------------------------------
    override bool VisibleInPalette() { return true; }
    
    protected static ref TStringArray s_aVarsIn = {
        PORT_BASE_TARGET
    };
    override TStringArray GetVariablesIn() { return s_aVarsIn; }
}