SCR_AIUpdateTargetAttackData.c

Go to the documentation of this file.

class SCR_AIUpdateTargetAttackData : AITaskScripted
{   
    // Inputs
    protected static const string BASE_TARGET_PORT = "BaseTarget";
    protected static const string WEAPON_IS_READY = "WeaponReady";
    
    
    // Outputs
    protected static const string PORT_LAST_SEEN_POSITION = "LastSeenPosition";
    protected static const string PORT_VISIBLE = "Visible";
    protected static const string PORT_FIRE_TREE_ID = "FireTreeId";
    static const string PORT_AIMPOINT_TYPE_0 = "AimpointType0";
    static const string PORT_AIMPOINT_TYPE_1 = "AimpointType1";
    
    // These IDs must match to actual trees in attack tree
    protected const int FIRE_TREE_INVALID       = -1;   // No aiming or firing is allowed at all
    protected const int FIRE_TREE_LOOK          = 0;    // Looking at target without firing
    protected const int FIRE_TREE_BURST         = 1;
    protected const int FIRE_TREE_SINGLE        = 2;
    protected const int FIRE_TREE_SUPPRESSIVE   = 3;
    protected const int FIRE_TREE_MELEE         = 4;
    
    protected const float MELEE_MAX_DISTANCE = 2.0;
    protected const float BURST_FIRE_MAX_DISTANCE = 50.0;
    
    protected SCR_AICombatComponent m_CombatComponent;
    protected CharacterControllerComponent m_CharacterController;
    protected PerceptionComponent m_PerceptionComponent;
    protected SCR_AIUtilityComponent m_UtilityComponent;
    
    // Flag for executing some logic only once at start
    protected bool m_bFirstSimulate = true;
    
    protected bool m_bWeaponHasBurstOrAuto; // Cached on first run
    
    
    //-----------------------------------------------------------------------------------------------------
    override void OnInit(AIAgent owner)
    {
        m_UtilityComponent = SCR_AIUtilityComponent.Cast(owner.FindComponent(SCR_AIUtilityComponent));
        
        IEntity myEntity = owner.GetControlledEntity();
        if (myEntity)
        {
            m_CombatComponent = SCR_AICombatComponent.Cast(myEntity.FindComponent(SCR_AICombatComponent));
            m_PerceptionComponent = PerceptionComponent.Cast(myEntity.FindComponent(PerceptionComponent));
            m_CharacterController = CharacterControllerComponent.Cast(myEntity.FindComponent(CharacterControllerComponent));
        }
        
        m_bFirstSimulate = true;
    }
    
    //-----------------------------------------------------------------------------------------------------
    override void OnAbort(AIAgent owner, Node nodeCausingAbort)
    {
        m_bFirstSimulate = true;
    }
    
    //-----------------------------------------------------------------------------------------------------
    override ENodeResult EOnTaskSimulate(AIAgent owner, float dt)
    {
        BaseTarget target;
        GetVariableIn(BASE_TARGET_PORT, target);
        
        bool weaponReady;
        GetVariableIn(WEAPON_IS_READY, weaponReady);
        
        if (!target || !m_CombatComponent || !m_PerceptionComponent || !m_CharacterController || !m_UtilityComponent)
            return ENodeResult.FAIL;
        
        if (m_bFirstSimulate)
        {
            BaseWeaponComponent selectedWeaponComp;
            int selectedMuzzleId;
            m_CombatComponent.GetSelectedWeapon(selectedWeaponComp, selectedMuzzleId);
            m_bWeaponHasBurstOrAuto = WeaponHasBurstOrAutoMode(selectedWeaponComp, selectedMuzzleId);
        }
        
        // Last seen pos
        SetVariableOut(PORT_LAST_SEEN_POSITION, target.GetLastSeenPosition());
        
        // Visible?
        bool visible = m_CombatComponent.IsTargetVisible(target);
        SetVariableOut(PORT_VISIBLE, visible);
        
        // Which fire tree to use?
        // This must be reevaluated periodically
        int fireTreeId = ResolveFireTree(target, visible, weaponReady);
        SetVariableOut(PORT_FIRE_TREE_ID, fireTreeId);
        
        // Which aimpoints to use?
        // We run this only once, since it's not going to change much
        if (m_bFirstSimulate)
        {
            EAimPointType aimpointType0;
            EAimPointType aimpointType1;
            ResolveAimpointTypes(target, aimpointType0, aimpointType1);
            SetVariableOut(PORT_AIMPOINT_TYPE_0, aimpointType0);
            SetVariableOut(PORT_AIMPOINT_TYPE_1, aimpointType1);
        }
        
        // Reset m_bFirstSimulate flag
        m_bFirstSimulate = false;
        
        return ENodeResult.SUCCESS;
    }
    
    //-----------------------------------------------------------------------------------------------------
    // Evaluates which fire tree should be used
    int ResolveFireTree(BaseTarget target, bool visible, bool weaponReady)
    {
        // Is aiming forbidden by combat move?
        SCR_AIBehaviorBase executedBehavior = SCR_AIBehaviorBase.Cast(m_UtilityComponent.GetExecutedAction());
        if (executedBehavior && executedBehavior.m_bUseCombatMove && !m_UtilityComponent.m_CombatMoveState.m_bAimAtTarget)
            return FIRE_TREE_INVALID;
        
        // Is weapon not ready?
        if (!weaponReady)
            return FIRE_TREE_LOOK;
        
        BaseWeaponComponent selectedWeaponComp;
        int selectedMuzzleId;
        m_CombatComponent.GetSelectedWeapon(selectedWeaponComp, selectedMuzzleId);
        
        bool directDamage
        float weaponMinDist, weaponMaxDist;
        m_CombatComponent.GetSelectedWeaponProperties(weaponMinDist, weaponMaxDist, directDamage);
        
        if (!selectedWeaponComp)
            return FIRE_TREE_LOOK;
        
        EWeaponType weaponType = selectedWeaponComp.GetWeaponType();
        
        float targetDistance = target.GetDistance();
        
        // Use melee?
        if (targetDistance < MELEE_MAX_DISTANCE &&
            !m_CharacterController.CanFire() &&
            m_CharacterController.GetStance() != ECharacterStance.PRONE)
        {
            return FIRE_TREE_MELEE;
        }
        
        // Friendly in aim?
        if (m_PerceptionComponent.GetFriendlyInLineOfFire())
        {
            return FIRE_TREE_LOOK;
        }
    
        
        // Not melee
        
        if (targetDistance < weaponMinDist || targetDistance > weaponMaxDist)
        {
            // Outside weapon usage range
            // Look at target
            
            return FIRE_TREE_LOOK;
        }
        
 
        // Within weapon usage range
        
        if (visible)
        {
            // Visible
            // If machinegun, always use burst at any range
            // For regular weapons, use burst at short range if available, otherwise single
            if (weaponType == EWeaponType.WT_MACHINEGUN)
                return FIRE_TREE_BURST;
            else if (targetDistance < BURST_FIRE_MAX_DISTANCE && m_bWeaponHasBurstOrAuto)
                return FIRE_TREE_BURST;
            else
                return FIRE_TREE_SINGLE;
            
        }
        else
        {
            // Invisible
            // Use suppressive fire or don't fire at all
            
            // If weapon is configured to deal indirect damage, then use it for invisible target
            // Otherwise regular weapons can also be used to fire at hidden target,
            // except for rocket launchers, their ammo is too valuable
            // Also ensure we don't do suppressive fire into a wall in front of us
            
            float lastSeenThreshold;
            if (weaponType == EWeaponType.WT_MACHINEGUN)
                lastSeenThreshold = SCR_AICombatComponent.TARGET_MAX_LAST_SEEN_INDIRECT_ATTACK_MG;
            else
                lastSeenThreshold = SCR_AICombatComponent.TARGET_MAX_LAST_SEEN_INDIRECT_ATTACK;
            
            if ((!directDamage || weaponType != EWeaponType.WT_ROCKETLAUNCHER) &&
                target.GetTimeSinceSeen() < lastSeenThreshold &&
                target.GetTraceFraction() > 0.5)
                return FIRE_TREE_SUPPRESSIVE;
            else
                return FIRE_TREE_LOOK;
        }
        
        return FIRE_TREE_LOOK;
    }
 
    //-----------------------------------------------------------------------------------------------------
    static bool WeaponHasBurstOrAutoMode(notnull BaseWeaponComponent weaponComp, int muzzleId)
    {       
        array<BaseMuzzleComponent> muzzles = {};
        weaponComp.GetMuzzlesList(muzzles);
        
        if (!muzzles.IsIndexValid(muzzleId))
            return false;
        
        BaseMuzzleComponent muzzle = muzzles[muzzleId];
        if (!muzzle)
            return false;
        
        array<BaseFireMode> fireModes = {};
        muzzle.GetFireModesList(fireModes);
        foreach (BaseFireMode mode : fireModes)
        {
            EWeaponFiremodeType modeType = mode.GetFiremodeType();
            if (modeType == EWeaponFiremodeType.Burst || modeType == EWeaponFiremodeType.Auto)
                return true;
        }
        return false;
    }
    
    //-----------------------------------------------------------------------------------------------------
    void ResolveAimpointTypes(notnull BaseTarget target, EAimPointType aimpointType0, EAimPointType aimpointType1)
    {
        IEntity targetEntity = target.GetTargetEntity();
        if (!targetEntity)
        {
            aimpointType0 = -1;
            aimpointType1 = -1;
            return;
        }
                    
        ChimeraCharacter character = ChimeraCharacter.Cast(targetEntity);
        if (character)
        {
            // Characters
            
            if (character.IsInVehicle())
            {
                // Aim at head
                aimpointType0 = EAimPointType.WEAK;
                aimpointType1 = EAimPointType.NORMAL;
                return;
            }
            
            aimpointType0 = EAimPointType.NORMAL;
            aimpointType1 = EAimPointType.WEAK;
            return;
        }
        else
        {
            // Vehicles and the rest
            
            EWeaponType weaponType = m_CombatComponent.GetSelectedWeaponType();
            
            if (weaponType == EWeaponType.WT_ROCKETLAUNCHER)
            {
                // Rocket launcher, aim at weak point
                aimpointType0 = EAimPointType.WEAK;
                aimpointType1 = EAimPointType.NORMAL;
                return;
            }
            
            aimpointType0 = EAimPointType.NORMAL;
            aimpointType1 = EAimPointType.WEAK;
            return;
        }
    }
        
    //-----------------------------------------------------------------------------------------------------
    protected ref TStringArray s_aVarsIn = {
        BASE_TARGET_PORT,
        WEAPON_IS_READY
    };
    override TStringArray GetVariablesIn() { return s_aVarsIn; }
    
    protected ref TStringArray s_aVarsOut = {
        PORT_VISIBLE,
        PORT_LAST_SEEN_POSITION,
        PORT_FIRE_TREE_ID,
        PORT_AIMPOINT_TYPE_0,
        PORT_AIMPOINT_TYPE_1
    };
    override TStringArray GetVariablesOut() { return s_aVarsOut; }
    
    override bool VisibleInPalette() { return true; }
    
    override string GetOnHoverDescription() { return "Special node which is used in attack behavior"; };
 
}