KF2-Dev-Scripts/KFGame/Classes/KFAIController_Hans.uc

//=============================================================================
// KFAIController_Hans
//=============================================================================
// Hans's AIController
//=============================================================================
// Killing Floor 2
// Copyright (C) 2015 Tripwire Interactive LLC
//=============================================================================

class KFAIController_Hans extends KFAIController_ZedBoss
	native(AI);

/*********************************************************************************************
* Initialization
********************************************************************************************* */
/** Cached copy of Hans pawn to avoid casting */
var transient KFPawn_ZedHansBase	MyHansPawn;

/** Destination navigation point Hans wants to throw a grenade from */
//var NavigationPoint RangedAttackMoveGoal;
var vector          RangedAttackMoveLoc;
var bool			bFoundGrenadeThrowLocation;
var bool			bWantsToThrowGrenade;

var vector          CalcedGreanadeTossVelForNavMeshLoc;
var float           TimeCalcedGreanadeTossVelWasFound;
var vector          EnemysLocationWhenTossVelWasFound;

/*********************************************************************************************
* Sprint behavior
**********************************************************************************************/

/** How long Hans should wait to start sprinting after losing sight of his enemy */
var             float           LostSightSprintDelay;

/*********************************************************************************************
* Gun shooting related variables brought over from AICommand_HansGunAttack.
* Put here because the shoot AICommand keeps getting pushed onto the stack and
* resetting these vars
**********************************************************************************************/

/** The time a new barrage started */
var             float           BarrageStartTime;
/** The last time we started firing our gun */
var             float           LastFireTime;
/** The time we started drawing our gun */
var             float			StartDrawGunsTime;
/** The time we started this gun attack */
var             float			StartGunAttackTime;
/** Cache our last target */
var             Actor           LastTarget;
/** The time we first saw our current target we are shooting at */
var             float			TimeFirstSawTarget;

/** Last time we changed weapon stances */
var             float			LastStanceChangeTime;
/** Can't change stances more often than this */
var()   	    float			StanceChangeCooldown;

/** Last time we finished a melee attack */
var             float			LastAttackMoveFinishTime;
/** Wait this long to do a gun attack after doing a melee attack */
var()   	    float			PostAttackMoveGunCooldown;

/*********************************************************************************************
* Enemy Tracking
**********************************************************************************************/

/**
 *	Struct to track AI knowledge of visible enemies
 */
struct native TrackedEnemyInfo
{
	/** Enemy we're tracking */
	var KFPawn         TrackedEnemy;
	/** Enemy we're tracking */
	var float          LastTimeVisible;
	/** Enemy we're tracking */
	var vector         LastVisibleLocation;
	/** The last time we fired on this enemy */
	var float          LastTimeFiredOn;
	/** The last time we tossed a grenade at this enemy */
	var float          LastTimeGrenadeAttacked;
	/** How often we've chosen this enemy as a target recently */
	var int            NumTimesEngagedRecently;
};

/** List of tracked enemies that have recently been seen */
var array<TrackedEnemyInfo> RecentlySeenEnemyList;

/** The last enemy we gunned at that was recently seen */
var KFPawn LastRecentlySeenEnemyGunned;

/** The last enemy we grenaded that was recently seen */
var KFPawn LastRecentlySeenEnemyGrenaded;

/** How often to update RecentlySeenEnemyList */
var() float RecentSeenEnemyListUpdateInterval;

/** Last time we updated the RecentlySeenEnemyList*/
var float LastRecentSeenEnemyListUpdateTime;

/** The last time we changed to a new target */
var float LastRetargetTime;

/** How long to wait before attempting to find a new target */
var vector2d RetargetWaitTimeRange;

/** The actual retarget wait time after last retarget time has been set */
var transient float ActualRetargetWaitTime;

/*********************************************************************************************
* Vars for handing the timing of firing, when to shoot, the shooting cadence, etc
**********************************************************************************************/
/** Min length of a burst for this weapon when used by AI. Randomly used to calculate the BurstAmount */
var(Firing)	    int				MinBurstAmount;
/** Max length of a burst for this weapon when used by AI. Randomly used to calculate the BurstAmount */
var(Firing)	    int				MaxBurstAmount;
/** How long to wait between bursts when this weapon is used by AI */
var(Firing)	    float			BurstWaitTime;
/** How long to wait between barrages (groups of bursts) when this weapon is used by AI */
var(Firing)	    float			BarrageWaitTime;

/** Interp curve to scale how long Hans waits between barrages for different ranges **/
var() InterpCurveFloat BarrageWaitDistanceCurve;

/** Interp curve to scale how long Hans waits between bursts for different ranges **/
var() InterpCurveFloat BurstWaitDistanceCurve;

/** How long a barrage (groups of bursts) will last */
var(Firing)	    float			BarrageLength;
/** Tracks the current burst and what size it is */
var     	    int				BurstAmount;
/** How long to wait to stop firing after losing sight of an enemy */
var(Firing)	    float			LostSightStopFireDelay;
/** The fire mode the last time we fired our gun */
var             float           LastFireMode;
/** How long to wait after starting to draw our guns to fire */
var(Firing)	    float			DrawGunFireDelay;
/** How long to wait after starting to see an enemy to fire */
var(Firing)	    float			TargetAquisitionDelay;
/** How long this gun attack should last at the max */
var(Firing)	    float			MaxGunAttackLength;
/** How long to wait after drawing the guns before allowing a grenade toss to interrupt them */
var(Firing)	    float			GrenadeGunInterruptDelay;

/** The range the zed needs to be within to start shooting bullets */
var float StartShootingRange;

/** The range the zed needs to be outside to disallow shooting bullets */
var float MinShootingRange;

/** min delay between shooting attacks */
var float ShootingCooldown;

enum EHansNadeType
{
    HNT_None,
    HNT_HEGrenade,
    HNT_NerveGas,
    HNT_Smoke,
    HNT_HEGrenadeBarrage,
    HNT_NerveGasBarrage,
    HNT_SmokeBarrage,
};

/* The grenade attack type we have queued up to do */
var EHansNadeType CurrentNadeAttackType;

/* How often to check if we want to do a grenade attack */
var() float GrenadeAttackEvalInterval;

/* Last time we evaluated if we wanted to do a grenade attack*/
var float LastGrenadeAttackEvalTime;

/** Whether we've already thrown a smoke grenade barrage this hunt and heal phase */
var bool bHasUsedSmokeScreenThisPhase;

/*********************************************************************************************
* Fleeing
**********************************************************************************************/

/** TRUE if flee is in progress */
var bool bFleeing;

/** TRUE if flee was interrupted (to attack, etc) */
var bool bWantsToFlee;

/** Set to true once the flee has been completed */
var bool bHasFledThisPhase;

/** How long we should flee */
var float MinFleeDuration, MaxFleeDuration;

/** Maximum flee distance */
var float MaxFleeDistance;

/** The start time of the last flee */
var float FleeStartTime;

/** The total cumulative time spent fleeing */
var float TotalFleeTime;

/** Whether the flee was interrupted by the targeting loop */
var bool bFleeInterrupted;

cpptext
{
	/** Overridden to allow grab attack check */
	virtual UBOOL TickMeleeCombatDecision( FLOAT DeltaTime );
}

/*********************************************************************************************
* Initialization, Pawn Possession, and Destruction
********************************************************************************************* */

/** Set MyHansPawn to avoid casting */
event Possess( Pawn inPawn, bool bVehicleTransition )
{
	if( KFPawn_ZedHansBase(inPawn) != none )
	{
		MyHansPawn = KFPawn_ZedHansBase( inPawn );
	}
	else
	{
		`warn( GetFuncName()$"() attempting to possess "$inPawn$", but it's not a KFPawn_ZedHansBase class! MyHansPawn variable will not be valid." );
	}

    // Initialize retarget time
    LastRetargetTime = WorldInfo.TimeSeconds;
    ActualRetargetWaitTime = RandRange( RetargetWaitTimeRange.X, RetargetWaitTimeRange.Y );

	super.Possess( inPawn, bVehicleTransition );
}

function PawnDied( Pawn InPawn )
{
	if( MyHansPawn != none )
	{
		`DialogManager.PlayBossDeathDialog( MyHansPawn );
		MyHansPawn = None;
	}
	Super.PawnDied( InPawn );
}

/** Clean up all internal objects and references when the AI is destroyed
	TBD: Look into using Unpossessed() to do this! */
simulated event Destroyed()
{
	MyHansPawn = None;

	super.Destroyed();
}

/** Overridden to allow grab attack check */
/*
function DoMeleeAttack( optional Pawn NewEnemy, optional Actor InTarget, optional byte AttackFlags )
{
	local float DistSq;

	if( CommandList == None || AICommand(CommandList).bAllowedToAttack )
	{
		DistSq = VSizeSq( Enemy.Location - Pawn.Location );

		if( DistSq < 32400.f || DistSq > 10000.f )
		{
			if( CanGrabAttack() )
			{
				//	DumpCommandStack();
				DoGrabAttack();
				return;
			}
		}
	}
	super.DoMeleeAttack( NewEnemy, inTarget, AttackFlags );
}
*/

/** Start the throw grenade command, optionally for the grenade barrage attack */
function DoGrenadeThrow( optional bool bGrenadeBarrage )
{
    if( MyHansPawn != none )
    {
        MyHansPawn.SetActiveGrenadeClassGrenade();
    }

	if( class'AICommand_ThrowGrenade'.static.ThrowGrenade(self, bGrenadeBarrage ? 2 : 0) )
	{
        if( MyHansPawn != none )
        {
            MyHansPawn.BarrageTossCount=0;
            MyHansPawn.bDoingBarrage=bGrenadeBarrage;
        }
	}
}

/** Start the throw grenade command with smoke, optionally for the grenade barrage attack */
function DoSmokeGrenadeThrow( optional bool bGrenadeBarrage, optional bool bIsHuntAndHeal )
{
    local bool bThrowSuccess;

    if( MyHansPawn != none )
    {
        MyHansPawn.SetActiveGrenadeClassSmoke();
    }

    // Spawn some zeds if we need to
    bThrowSuccess = class'AICommand_ThrowGrenade'.static.ThrowGrenade(self, bGrenadeBarrage ? 1 : 0, bIsHuntAndHeal);

	if( bThrowSuccess )
	{
        if( MyHansPawn != none )
        {
            MyHansPawn.bPendingSmokeGrenadeBarrage=false;
            MyHansPawn.BarrageTossCount=0;
            MyHansPawn.bDoingBarrage=bGrenadeBarrage;
        }
	}
}

/** Notification from the pawn that it has taken damage */
function NotifyTakeHit( Controller InstigatedBy, vector HitLocation, int Damage, class<DamageType> damageType, vector Momentum )
{
    local float HealThreshold, HealthPct;

    super.NotifyTakeHit( InstigatedBy, HitLocation, Damage, damageType, Momentum );

    // When our health gets low, go hunt a player to draw life and enter the next battle phase
    if( !MyHansPawn.bHealedThisPhase && MyHansPawn.CurrentBattlePhase < 4 )
    {
        HealThreshold = MyHansPawn.BattlePhases[MyHansPawn.CurrentBattlePhase-1].HealThresholds[WorldInfo.Game.GetModifiedGameDifficulty()];
        HealthPct = GetHealthPercentage();

        // Summon minions if we haven't yet
        if( !bSummonedThisPhase && HealthPct < HealThreshold + 0.18f ) //0.16
        {
            MyHansPawn.SummonMinions();
            bSummonedThisPhase = true;

            // Fallback so zeds can't spawn forever
            SetTimer( 30.f, false, nameOf(Timer_StopSummoningZeds) );
        }

        // Enter hunt and heal mode if we've dropped below the health threshold
        if( HealthPct < HealThreshold )
        {
            MyHansPawn.SetHuntAndHealMode( true );
        }
    }
}

/** Special move has ended, whether cleanly or aborted */
function NotifySpecialMoveEnded(KFSpecialMove SM)
{
    super.NotifySpecialMoveEnded(SM);

    // Our guns are put away, toss some grenades
    if( !bWantsToFlee && !bFleeing && Enemy != None && MyHansPawn != none && MyHansPawn.bPendingSmokeGrenadeBarrage )
    {
        DoSmokeGrenadeThrow( true, true );
    }

    if( SM.Handle == 'KFSM_MeleeAttack'
        || SM.Handle == 'KFSM_Hans_GrenadeBarrage'
        || SM.Handle == 'KFSM_Hans_GrenadeHalfBarrage'
        || SM.Handle == 'KFSM_Hans_ThrowGrenade'
        || SM.Handle == 'KFSM_Taunt'
        || SM.Handle == 'KFSM_WalkingTaunt' )
    {
        LastAttackMoveFinishTime = WorldInfo.TimeSeconds;
    }

    // Handle flee interruptions
    if( !bWantsToFlee )
    {
        // Retarget if it's been enough time since we changed targets
        if( SM.Handle == 'KFSM_MeleeAttack' && `TimeSince(LastRetargetTime) > ActualRetargetWaitTime )
        {
            CheckForEnemiesInFOV( 3000.f, -1.f, 1.f, true );
        }
    }
    else if( MyHansPawn.bGunsEquipped )
    {
        class'AICommand_Hans_GunStance'.static.SetGunStance( self, 0 );
    }
    else if( PendingDoor == none && !bFleeing )
    {
        Flee();

        // Play dialog indicating the next phase has started
        if( !bFleeInterrupted )
        {
            `DialogManager.PlayHansSmokeDialog( MyHansPawn, true );
        }
    }

    // Reset flee interrupted flag in case this was an attack special move
    bFleeInterrupted = false;

    // Evaluate sprinting whenever we finish a special move so sprinting will be snappy!
    EvaluateSprinting();
}

/** Evaluate if we should start/stop sprinting, and then set the sprinting flag */
function EvaluateSprinting()
{
    if( MyKFPawn == none || !MyKFPawn.IsAliveAndWell() )
    {
        return;
    }

    if( bFleeing || bWantsToFlee )
    {
        MyKFPawn.SetSprinting( true );
    }
    else if( Enemy != none )
	{
		if( ShouldSprint() )
		{
			MyKFPawn.SetSprinting( true );
		}
		else
		{
			MyKFPawn.SetSprinting( false );
		}
	}
}

/** NPC has seen a player - use SeeMonster for similar notifications about seeing any pawns (currently not in use) */
event SeePlayer( Pawn Seen )
{
    local int EnemyListIndex;
    local TrackedEnemyInfo NewTrackedEnemy;
    local KFPawn KFP;

    Super.SeePlayer(Seen);

	// Evaluate sprinting when visibility changes
    EvaluateSprinting();

	// Reject potential enemy if it's invalid or not on our team, or if it's already my current enemy, or if my pawn is dead or invalid
	if( Seen == none || !Seen.IsAliveAndWell() || Pawn.IsSameTeam( Seen ) ||
		Pawn == none || !Pawn.IsAliveAndWell() || !Seen.CanAITargetThisPawn(self) )
	{
		return;
	}

    KFP = KFPawn(Seen);

    // Add or update recently seen enemy in the list for tracking ranged enemies
    if( KFP != none )
    {
        EnemyListIndex = RecentlySeenEnemyList.Find('TrackedEnemy', KFP);

        if( EnemyListIndex == INDEX_NONE )
        {
            NewTrackedEnemy.TrackedEnemy = KFP;
            NewTrackedEnemy.LastTimeVisible = WorldInfo.TimeSeconds;
            NewTrackedEnemy.LastVisibleLocation = Seen.Location;
            RecentlySeenEnemyList[RecentlySeenEnemyList.Length] = NewTrackedEnemy;
        }
        else
        {
            RecentlySeenEnemyList[EnemyListIndex].LastTimeVisible = WorldInfo.TimeSeconds;
            RecentlySeenEnemyList[EnemyListIndex].LastVisibleLocation = Seen.Location;
        }
    }

    // Throw down our smoke screen before going after a player to heal
    if( bHasFledThisPhase && MyHansPawn.bInHuntAndHealMode && !bHasUsedSmokeScreenThisPhase )
    {
        bHasUsedSmokeScreenThisPhase = true;        
        SetTimer( 2.f + fRand(), false, nameOf(Timer_DoHuntAndHealSmokeGrenadeThrow) );
    }
}

/** Throws a smoke grenade barrage after waiting a short time */
function Timer_DoHuntAndHealSmokeGrenadeThrow()
{
    // Toss some smoke grenades out and summon some minions to help
    // while I try and find someont to suck some life from. If Hans
    // has his guns out, set the flag to wait til his guns are put
    // away before trying to throw the smoke grenade barrage and
    // Spawn the minion zeds
    if( !MyHansPawn.bGunsEquipped && !MyHansPawn.IsImpaired() && !MyHansPawn.IsIncapacitated() )
    {
        DoSmokeGrenadeThrow( true );
    }
    else
    {
        MyHansPawn.bPendingSmokeGrenadeBarrage = true;
    }
}

/** Start the throw grenade command with nerve gas, optionally for the grenade barrage attack */
function DoNerveGasGrenadeThrow( optional bool bGrenadeBarrage )
{
    if( MyHansPawn != none )
    {
        MyHansPawn.SetActiveGrenadeClassNerveGas();
    }

	if( class'AICommand_ThrowGrenade'.static.ThrowGrenade(self, bGrenadeBarrage ? 1 : 0) )
	{
        if( MyHansPawn != none )
        {
            MyHansPawn.BarrageTossCount=0;
            MyHansPawn.bDoingBarrage=bGrenadeBarrage;
        }
	}
}

/** Timer function called during latent moves that determines whether NPC should sprint or stop sprinting */
function bool ShouldSprint()
{
    local float RangeToEnemy;

	if( Enemy != none && MyHansPawn != none && !MyHansPawn.bIsHeadless && !MyHansPawn.bEmpPanicked )
	{
		// Always sprint if we're trying to track down players to heal from
        if( MyHansPawn.bInHuntAndHealMode )
		{
			//`log(self@GetFuncName()$" bInHuntAndHealMode should sprint!");
            return true;
		}

		// Sprint if we can't see our enemy
		if( LastEnemySightedTime == 0 || `TimeSince(LastEnemySightedTime) > LostSightSprintDelay )
		{
			//`log(self@GetFuncName()$" don't see any enemy should sprint = true! LastEnemySightedTime: "$LastEnemySightedTime$" TimeSince(LastEnemySightedTime): "$`TimeSince(LastEnemySightedTime));
            return true;
		}

        // No sprinting with the guns out!
        if( MyHansPawn.bGunsEquipped )
        {
            RangeToEnemy = VSize( Enemy.Location - Pawn.Location );

            // Sprint if we're too close to shoot
            if( RangeToEnemy > StartShootingRange*MyHansPawn.GetAttackRangeScale() || rangeToEnemy < MinShootingRange )
            {
                //`log(self@GetFuncName()$" guns out but enemy not in gun range. Should sprint = true!");
                return true;
            }
            else
            {
                //`log(self@GetFuncName()$" guns out enemy not in gun range. Should sprint = false!");
                return false;
            }
        }

        //`log(self@GetFuncName()$" Generic should sprint depending on phase: "$MyHansPawn.DesireSprintingInThisPhase());
        return MyHansPawn.DesireSprintingInThisPhase();
	}
	//`log(self@GetFuncName()$" Generic should sprint = false!");
	return false;
}

/*********************************************************************************************
* Combat
**********************************************************************************************/

/*********************************************************************************************
* Shooting
********************************************************************************************* */

/**
 * Handle the firing of the pawn's weapon
 */
function FireTimer()
{
    local float UsedBarrageWaitTime, UsedBurstWaitTime;

	// if we no longer have an Enemy or a pawn return
	if ( Enemy == none || Pawn == none )
	{
		// We've got nothing to Fire at
		ClearFireTiming();
		return;
	}

	// Lost sight of enemy, stop firing
	if( !CanSee(Enemy) && (WorldInfo.TimeSeconds - LastEnemySightedTime >= LostSightStopFireDelay) )
	{
		//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Can't see the enemy, stopping shooting TimeDiff: "$`TimeSince(LastEnemySightedTime)$" LostSightStopFireDelay = "$LostSightStopFireDelay);
		ClearFireTiming();
		TimeFirstSawTarget=0;
        // Clear any previous barrage so we start firing again immediately after reacquiring the target
        BarrageStartTime = 0;
		return;
	}

    // Don't fire during a Melee attack!
    if( MyKFPawn.IsDoingMeleeAttack() )
    {
		ClearFireTiming();
		return;
    }

	// if there is a friendly in the way don't fire!
//	if( IsFriendlyBlockingFireLine() )
//	{
//		// `CombatLog(Self$" "$GetStateName()$" "$GetFuncName()$"() Friendly blocking fire line, not shooting");
//		SetTimer(0.5, false, 'FireTimer');
//		return;
//	}

    // Store some info so we can time target acquisition
    if( LastTarget == none || TimeFirstSawTarget == 0 )
    {
        LastTarget = Enemy;
        TimeFirstSawTarget = WorldInfo.TimeSeconds;
    }

    // Wait to fire until the TargetAquisitionDelay is over
    if( TimeFirstSawTarget > 0 && `TimeSince(TimeFirstSawTarget) < TargetAquisitionDelay )
    {
        //`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Waiting to aquire target, TimeDiff: "$`TimeSince(TimeFirstSawTarget)$" TargetAquisitionDelay = "$TargetAquisitionDelay);
        SetTimer(TargetAquisitionDelay - `TimeSince(TimeFirstSawTarget), false, nameof(FireTimer), self);
        Pawn.StopFiring();
        // Clear any previous barrage so we start firing again immediately after reacquiring the target
        BarrageStartTime = 0;
        return;
    }

    // Pause between groups of bursts to give the firing a good cadence
    if( BarrageStartTime > 0 && `TimeSince(BarrageStartTime) > BarrageLength )
    {
        if( Enemy != none && Pawn != none  )
        {
            UsedBarrageWaitTime = BarrageWaitTime * EvalInterpCurveFloat(BarrageWaitDistanceCurve, VSize(Pawn.Location - Enemy.Location));
            //`log("Barrage Shooting at enemy that is "$VSize(Pawn.Location - Enemy.Location)/100.0$" meters away BarrageWait is "$UsedBarrageWaitTime$" scale is "$EvalInterpCurveFloat(BarrageWaitDistanceCurve, VSize(Pawn.Location - Enemy.Location)));
        }
        else
        {
            UsedBarrageWaitTime = BarrageWaitTime;

        }

        SetTimer(UsedBarrageWaitTime, false, nameof(FireTimer), self);

        BarrageStartTime = 0;
        Pawn.StopFiring();
        //`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Pausing between baragges");

        return;
    }
    else if( BarrageStartTime == 0 )
    {
        BarrageStartTime = WorldInfo.TimeSeconds;
    }

	// Reset the burst settings when we finish a burst
	if( BurstAmount == 0 )
	{
		//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Burst amount is 0");

		BurstAmount = RandRange(MinBurstAmount,MaxBurstAmount);

        // See if we can no longer shoot at our target when a burst ends
        if( !CanPerformShotAttack() )
        {
            //`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() BurstAmount hit zero, and CanPerformShotAttack is false so stopping shooting");
            ClearFireTiming();
            // Clear any previous barrage so we start firing again immediately after reacquiring the target
            BarrageStartTime = 0;
        }
        // Set up the next burst
        else
        {

            UsedBurstWaitTime = BurstWaitTime + ((FRand() * BurstWaitTime * 0.15) - (BurstWaitTime * 0.3));

            if( Enemy != none && Pawn != none  )
            {
                UsedBurstWaitTime = UsedBurstWaitTime * EvalInterpCurveFloat(BurstWaitDistanceCurve, VSize(Pawn.Location - Enemy.Location));
                //`log("Burst Shooting at enemy that is "$VSize(Pawn.Location - Enemy.Location)/100.0$" meters away BurstWaitTime is "$UsedBurstWaitTime$" scale is "$EvalInterpCurveFloat(BurstWaitDistanceCurve, VSize(Pawn.Location - Enemy.Location)));
            }

        	//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() BurstAmount hit zero, stopping firing. New BurstAmount is: "$BurstAmount);
        	SetTimer(UsedBurstWaitTime, false, nameof(FireTimer), self);
    		Pawn.StopFiring();

    		// Select a new enemy 50% of the time when a burst ends
            if( FRand() < 0.50 )
    		{
                SelectNewGunFireEnemy(KFPawn(Enemy));
    		}
		}
		return;
	}
	// if we can see our Enemy and we're facing our Enemy and we've waited long enough to shoot again
	if ( !Pawn.NeedToTurn(GetAimingLocation()) && WorldInfo.TimeSeconds - LastFireTime > Pawn.Weapon.FireInterval[LastFireMode] )
	{
		// Shoot at our Enemy and record the Fire Time
		Pawn.BotFire(true);
		LastFireMode = 0;
		// `Log("Time since last fire = "$(WorldInfo.TimeSeconds - LastFireTime));
		LastFireTime = WorldInfo.TimeSeconds;
		//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Shooting!!!!! BurstAmount is: "$BurstAmount);

		SetTimer(Pawn.Weapon.FireInterval[LastFireMode] * BurstAmount, false, nameof(FireTimer), self);
		BurstAmount = 0;

		`DialogManager.PlayBeingShotAtDialog( KFPawn_Human(Enemy), MyKFPawn );
	}
	else
	{
		//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Not Shooting NeedToTurn = "$Pawn.NeedToTurn(Enemy.Location)$" Last Fire Diff = "$(WorldInfo.TimeSeconds - LastFireTime)$" FireInterval = "$Pawn.Weapon.FireInterval[0]);
		SetTimer(0.1, false, nameof(FireTimer), self);
	}
}

/**
 * Clear firing cycle
 */
function ClearFireTiming()
{
    SetTimer(0.0, false, nameof(FireTimer), self);
	SetTimer(0.0, false, nameof(StartFireTiming), self);
	if( Pawn != none )
	{
		Pawn.StopFiring();
	}
}

/** Set a new enemy, returns false potential enemy is a player and AI is set to ignore players */
event bool SetEnemy( Pawn NewEnemy )
{
    // Don't let Hans switch enemies in the middle of draining his current enemy,
    // unless that enemy is dead
    if( !CanSwitchEnemies()
        || (MyKFPawn != none && MyKFPawn.IsDoingSpecialMove(SM_GrappleAttack) && Enemy != none
        && Enemy.IsAliveAndWell() && Enemy.CanAITargetThisPawn(self)) )
    {
        return false;
    }

    return Super.SetEnemy( NewEnemy );
}

/** Overridden to stop retargeting enemies when fleeing or cloaked */
event ChangeEnemy( Pawn NewEnemy, optional bool bCanTaunt = true )
{
    local Pawn OldEnemy;

    if( !CanSwitchEnemies() )
    {
        return;
    }

    OldEnemy = Enemy;

    super.ChangeEnemy( NewEnemy, bCanTaunt );

    if( OldEnemy != Enemy )
    {
        LastRetargetTime = WorldInfo.TimeSeconds;
        ActualRetargetWaitTime = RandRange( RetargetWaitTimeRange.X, RetargetWaitTimeRange.Y );
    }
}

/**
 * Pick a different visible enemy to fire at so we can cycle between enemies
 */
function SelectNewGunFireEnemy( KFPawn CurrentEnemy )
{
    local int RandIdx, i;
    local array<TrackedEnemyInfo> TargetCandidates;
//    local Vector	CamLoc;
//	local Rotator	CamRot;
//	local Vector	X, Y, Z;
	local int EnemyListIndex;

    // Randomly pick another visible enemy to shoot at
    if( RecentlySeenEnemyList.Length > 0 )
    {
    	// Validate targets to shoot
        for( i = RecentlySeenEnemyList.Length-1; i >= 0; i-- )
    	{
            if( RecentlySeenEnemyList[i].TrackedEnemy == none
                || !RecentlySeenEnemyList[i].TrackedEnemy.IsAliveAndWell()
                || !RecentlySeenEnemyList[i].TrackedEnemy.CanAITargetThisPawn(self) )
            {
                RecentlySeenEnemyList.Remove(i,1);
                continue;
            }
            else if( !MyHansPawn.NeedToTurnEx(RecentlySeenEnemyList[i].LastVisibleLocation, 0.0) )
            {
                TargetCandidates[TargetCandidates.Length] = RecentlySeenEnemyList[i];
            }
    	}

    	// Clear out this pawn if it was the last one we fired at and it was engaged recently
        for( i = TargetCandidates.Length-1; i >= 0; i-- )
    	{
            if( TargetCandidates.Length > 1 && TargetCandidates[i].TrackedEnemy == LastRecentlySeenEnemyGunned
                && `TimeSince(TargetCandidates[i].LastTimeFiredOn) < 3.0 )
            {
                TargetCandidates.Remove(i,1);
            }
    	}

    	// Target selection debugging
        // Get camera location/rotation
//    	GetPlayerViewPoint( CamLoc, CamRot );
//    	GetAxes( CamRot, X, Y, Z );
//      FlushPersistentDebugLines();
//    	DrawDebugCone(CamLoc,X,500.0, Acos(0.0), Acos(0.0),16,MakeColor(0,255,0,255),true);

        if( TargetCandidates.Length > 0 )
        {
            RandIdx = Rand(TargetCandidates.Length);
            //`log("Selected random gunfire target index "$RandIdx$" Pawn: "$TargetCandidates[RandIdx].TrackedEnemy);

            LastRecentlySeenEnemyGunned = TargetCandidates[RandIdx].TrackedEnemy;

            if( LastRecentlySeenEnemyGunned != none )
            {
                EnemyListIndex = RecentlySeenEnemyList.Find('TrackedEnemy', LastRecentlySeenEnemyGunned);

                if( EnemyListIndex != INDEX_NONE )
                {
                    RecentlySeenEnemyList[EnemyListIndex].LastTimeFiredOn = WorldInfo.TimeSeconds;
                }
            }
        }
    }
}

/**
 * Returns the location this AI should be aiming at to shoot its enemy.
 */
function vector GetAimingLocation()
{
	local KFPawn KFP;
	local vector AimingLocation;
	local int EnemyListIndex;

	KFP = KFPawn(Enemy);

    // Flag the last guy we selected to fire at and aim at him
    if( LastRecentlySeenEnemyGunned != none )
    {
        EnemyListIndex = RecentlySeenEnemyList.Find('TrackedEnemy', LastRecentlySeenEnemyGunned);

        if( EnemyListIndex != INDEX_NONE )
        {
            RecentlySeenEnemyList[EnemyListIndex].LastTimeFiredOn = WorldInfo.TimeSeconds;

            // We recently selected this guy to fire on
            if( `TimeSince(RecentlySeenEnemyList[EnemyListIndex].LastTimeFiredOn) < 1.0 )
            {
                KFP = LastRecentlySeenEnemyGunned;
            }
        }
    }

	if( KFP == none )
	{
		if( Focus != none )
		{
			AimingLocation = Focus.Location;
		}
		else if( Pawn != none )
		{
			AimingLocation = Pawn.Location + vector( Pawn.Rotation ) * 128;
		}
	}
	else
	{
		AimingLocation = KFP.Location + Vect(0,0,1) * KFP.BaseEyeHeight * 0.5;//KFP.Mesh.GetBoneLocation(KFP.HeadBoneName,0);
	}

	return AimingLocation;
}

/**
 * Start a firing cycle
 */
function StartFireTiming()
{
	// Check to see if its the first time we have fired, or the first time we've fired this attack.
	// If that is the case, fire now, then let the FireTimer handle any subsequent fires
	if( Pawn !=  none && Pawn.Weapon != none  )
	{
		if( `TimeSince( LastFireTime ) > (Pawn.Weapon.FireInterval[0] + BurstWaitTime + BurstWaitTime * 0.3) )
		{
			//`log(Self$" "$GetStateName()$" "$GetFuncName());
			BurstAmount = RandRange(MinBurstAmount,MaxBurstAmount);
			FireTimer();

		}
		else
		{
			//`log(Self$" "$GetStateName()$" "$GetFuncName()$" ?????????????????????????????? Not starting fire timing!!!");
		}
	}
}

/**
 * Validate the next gun shot attack
 */
function bool CanPerformShotAttack(optional bool bStart)
{
	local float rangeToEnemy;

    // No guns when fleeing
    if( bFleeing || bWantsToFlee )
    {
        return false;
    }

    // Don't start shooting if hans hasn't drawn his gun yet, or is already trying to fire
    if( bStart && ( Pawn.IsFiring()
                || IsTimerActive(nameof(FireTimer), self) || IsTimerActive(nameof(StartFireTiming), self)) )
    {
        //`log("bStart not shooting because: TimeSince(StartDrawGunsTime): "$`TimeSince(StartDrawGunsTime)$" <  DrawGunFireDelay: "$DrawGunFireDelay$" Pawn.IsFiring(): "$Pawn.IsFiring()$" FireTimer Active: "$IsTimerActive(nameof(FireTimer), self)$" StartFireTiming Active: "$IsTimerActive(nameof(StartFireTiming), self));
        return false;
    }

    // Don't start shooting if Hans just did a melee attack
    if( bStart && (`TimeSince(LastAttackMoveFinishTime) < PostAttackMoveGunCooldown) )
    {
        return false;
    }

    // Don't let us shoot if Hans hasn't had his guns out long enough
	if( `TimeSince(StartDrawGunsTime) < DrawGunFireDelay )
	{
		return false;
	}

    // Don't shoot while sprinting
    if( MyKFPawn != none && MyKFPawn.bIsSprinting )
    {
        return false;
    }

	if( Enemy != none )
	{
		if( bStart && LastShotTime > 0 && (`TimeSince(LastShotTime) < ShootingCooldown) )
		{
			return false;
		}

		if( MyKFPawn.IsImpaired() )
		{
			return false;
		}

		rangeToEnemy = VSize(Enemy.Location - MyKFPawn.Location);

		if( rangeToEnemy < StartShootingRange*MyHansPawn.GetAttackRangeScale() && rangeToEnemy > MinShootingRange && !MyKFPawn.IsDoingMeleeAttack() )
		{
			if( CanSee(Enemy) )
			{
				return true;
			}
			else if( (WorldInfo.TimeSeconds - LastEnemySightedTime) >= LostSightStopFireDelay )
        	{
        		//`Log(Self$" "$GetStateName()$" "$GetFuncName()$"() Can't see the enemy, can't shoot TimeDiff: "$`TimeSince(LastEnemySightedTime)$" LostSightStopFireDelay = "$LostSightStopFireDelay);
        		TimeFirstSawTarget=0;
        	}
		}
	}

	return false;
}

/**
 * Can I do a stance change right now
 */
function bool CanStanceChange()
{
    return (LastStanceChangeTime == 0 || (`TimeSince(LastStanceChangeTime) > StanceChangeCooldown));
}

/** Override to tick the ranged combat system */
simulated function Tick( FLOAT DeltaTime )
{
	Super.Tick(DeltaTime);

	if( Role == ROLE_Authority )
	{
	   TickRangedCombatDecision();
	}
}

/** Tick the ranged combat system */
function TickRangedCombatDecision()
{
    local int i;

    // Update the ranged enemy visibility tracking
    // TODO: update this slower if we aren't doing an attack!
    if( LastRecentSeenEnemyListUpdateTime == 0 || `TimeSince(LastRecentSeenEnemyListUpdateTime) > RecentSeenEnemyListUpdateInterval )
    {
        LastRecentSeenEnemyListUpdateTime = WorldInfo.TimeSeconds;

    	for( i = RecentlySeenEnemyList.Length-1; i >= 0; i-- )
    	{
    	   if( RecentlySeenEnemyList[i].TrackedEnemy == none
            || !RecentlySeenEnemyList[i].TrackedEnemy.IsAliveAndWell()
            || !RecentlySeenEnemyList[i].TrackedEnemy.CanAITargetThisPawn(self)
            || `TimeSince(RecentlySeenEnemyList[i].LastTimeVisible) > 5.0 )
    	   {
    	       RecentlySeenEnemyList.Remove(i,1);
    	   }
    	   else if( CanSee(RecentlySeenEnemyList[i].TrackedEnemy) )
    	   {
    	       RecentlySeenEnemyList[i].LastVisibleLocation = RecentlySeenEnemyList[i].TrackedEnemy.Location;
               RecentlySeenEnemyList[i].LastTimeVisible = WorldInfo.TimeSeconds;
    	   }
    	}
    }

    // No grenades or guns when fleeing
    if( bFleeing || bWantsToFlee )
    {
        return;
    }

    //Don't attack while we're in theatrics
    if (CommandList != none && CommandList.class == class'AICommand_BossTheatrics')
    {
        return;
    }

    if( Enemy != None && (LastGrenadeAttackEvalTime == 0 || `TimeSince(LastGrenadeAttackEvalTime) > GrenadeAttackEvalInterval) )
    {
        LastGrenadeAttackEvalTime = WorldInfo.TimeSeconds;

        if( SetupGrenadeAttack() )
        {
            if( CurrentNadeAttackType == HNT_HEGrenade )
            {
                DoGrenadeThrow( false );
            }
            else if( CurrentNadeAttackType == HNT_HEGrenadeBarrage )
            {
                DoGrenadeThrow( true );
            }
            else if( CurrentNadeAttackType == HNT_NerveGas )
            {
                DoNerveGasGrenadeThrow( false );
            }
            else if( CurrentNadeAttackType == HNT_NerveGasBarrage )
            {
                DoNerveGasGrenadeThrow( true );
            }
            else if( CurrentNadeAttackType == HNT_Smoke )
            {
                DoSmokeGrenadeThrow( false );
            }
        }
    }

    TickGunSystem();
}

/** Tick the gun attack system which handles drawing/putting away the weapon, starting the shooting cycle, etc */
function TickGunSystem()
{
	local KFPawn_ZedHansBase HansPawn;
	local KFSpecialMove curMove;
    local float rangeToEnemy;
    //local vector EyeLocation;
    local bool bGrenadeAttackInterrupt;

	if( MyKFPawn.SpecialMoves.Length > MyKFPawn.SpecialMove )
	{
		curMove = MyKFPawn.SpecialMoves[MyKFPawn.SpecialMove];
	}
	else
	{
		curMove = none;
	}

    if( Pawn.Physics == PHYS_Walking )
    {
        HansPawn = KFPawn_ZedHansBase(MyKFPawn);

		// Aiming debugging
        /*EyeLocation = MyKFPawn.Location + vect(0,0,1) * MyKFPawn.BaseEyeHeight;

        if( Focus == none )
        {
            if( IsZero(GetFocalPoint()) )
            {
                DrawDebugLine( EyeLocation, EyeLocation + normal( GetFocalPoint()) * 5000.f, 255, 0, 0, false );
            }
            else
            {
                DrawDebugLine( EyeLocation, EyeLocation + normal( GetFocalPoint() - EyeLocation ) * 5000.f, 0, 255, 0, false );
            }
        }
        else
        {
            DrawDebugLine( EyeLocation, Focus.Location, 255, 255, 0, false );
        }*/

        // Don't shoot if we're performing a special move that prevents it
        if( curMove != none && curMove.bDisablesWeaponFiring )
        {
            //`log("Not shooting because special move disallows it");
            if( Pawn.IsFiring() || IsTimerActive(nameof(FireTimer), self) || IsTimerActive(nameof(StartFireTiming), self) )
            {
                ClearFireTiming();
                // Clear any previous barrage so we are eligible to firing again right after special move is over
                BarrageStartTime = 0;
            }

            return;
        }

		// Make sure we're not in the middle of switching stances with the weapon, or doing boss theatrics
        if( HansPawn != none && (curMove == none || !MyKFPawn.IsDoingSpecialMove(SM_ChangeStance) && !MyKFPawn.IsDoingSpecialMove(SM_BossTheatrics)) )
		{
            // If we're firing at our target, aim at that location
            if( Pawn.IsFiring() || IsTimerActive(nameof(FireTimer), self) || IsTimerActive(nameof(StartFireTiming), self) )
            {
        		Focus = none;
        		SetFocalPoint( GetAimingLocation() );
            }
            // Switch back to aiming at our enemy if we're not moving to a pathnode
            else if( Focus == none )
            {
                Focus = Enemy;
            }

            if( Enemy != none )
            {
                rangeToEnemy = VSize(Enemy.Location - MyKFPawn.Location);
            }
            else
            {
                // If there is not enemy just act like they are out of range
                rangeToEnemy = MaxInt;
            }

            bGrenadeAttackInterrupt = GrenadeAttackInterruptGuns();

            // Put the guns away if the enemy is out of range
            if( HansPawn.bGunsEquipped && ((rangeToEnemy > StartShootingRange*MyHansPawn.GetAttackRangeScale() )
                || HansPawn.bInHuntAndHealMode || !HansPawn.CanUseGunsInThisPhase() || HansPawn.bPendingSmokeGrenadeBarrage
                || bGrenadeAttackInterrupt )
                && CanStanceChange() )
            {
                ClearFireTiming();
                class'AICommand_Hans_GunStance'.static.SetGunStance( self, 0 );
                //`log("Putting the guns away because there is an enemy too close");
            }
            // Draw the guns if the enemy is in range, and we're not waiting for a cooldown
            else if( !HansPawn.bGunsEquipped && (LastShotTime == 0 || (`TimeSince(LastShotTime) > ShootingCooldown))
                && rangeToEnemy < StartShootingRange*MyHansPawn.GetAttackRangeScale() && !HansPawn.bInHuntAndHealMode
                && HansPawn.CanUseGunsInThisPhase() && CanStanceChange() && !bGrenadeAttackInterrupt )
            {
                class'AICommand_Hans_GunStance'.static.SetGunStance( self, 1 );

                StartDrawGunsTime = WorldInfo.TimeSeconds;
                //`log("Drawing our guns StartDrawGunsTime = "$StartDrawGunsTime);

                // Clear any previous barrage so we are eligible to firing again right after special move is over
                BarrageStartTime = 0;

                // Don't start the cooldown again if we haven't already crossed the cooldown
                if( StartGunAttackTime == 0 || (`TimeSince(StartGunAttackTime) > MaxGunAttackLength) )
                {
                    StartGunAttackTime = WorldInfo.TimeSeconds;
                    //`log("Setting StartGunAttackTime = "$StartGunAttackTime);
                }
            }
            // Put the guns away if its time to cooldown or we can't use guns in this phase
            else if( StartGunAttackTime > 0 && (`TimeSince(StartGunAttackTime) > MaxGunAttackLength//StartDrawGunsTime > 0 && (`TimeSince(StartDrawGunsTime) > MaxGunAttackLength
                || !HansPawn.CanUseGunsInThisPhase() ) && CanStanceChange() )
            {
                //`log("Not shooting because we're in cooldown");
                if(  HansPawn.bGunsEquipped )
                {
                    ClearFireTiming();
                    LastShotTime = WorldInfo.TimeSeconds;
                    // Reset the draw guns time
                    StartDrawGunsTime = 0;
                    //`log("Putting our guns away StartDrawGunsTime = "$StartDrawGunsTime);

                    //`log("Putting Guns Away due to cooldown StartDrawGunsTime = "$StartDrawGunsTime$" LastShotTime = "$LastShotTime);

                    class'AICommand_Hans_GunStance'.static.SetGunStance( self, 0 );
                }
            }
            // All clear, start shooting!
            else if( HansPawn.bGunsEquipped && HansPawn.CanUseGunsInThisPhase()
                && CanPerformShotAttack(true) )
            {
            	//`DialogManager.PlayBeingShotAtDialog( KFPawn_Human(Enemy), HansPawn );
                StartFireTiming();
            }
        }
    }
}

/** Shows this KFAIController's RandgedAttack info on screen (see ShowAIInfo cheat) */
function DrawRangedAttackInfo( HUD Hud )
{
	local Canvas		Canvas;
    local float UsedShootCooldown;
	local KFSpecialMove curMove;
    local bool bMoveDisablesFiring;
    local float UsedGunAttackCooldown;
    local float UsedGlobalNadeAttackCooldown;
    local float UsedHENadeTossCooldown;
    local float UsedHENadeBarrageCooldown;
    local float UsedNerveGasTossCooldown;
    local float UsedNerveGasBarrageCooldown;
    local float UsedSmokeTossCooldown;
    local float UsedDrawGunsCooldown;
    local float UsedAttackMoveGunsCooldown;
    local float UsedGunTargetAquisitionCooldown;
    local int i;
    local vector EyeLocation;

	if( MyKFPawn == none )
	{
		return;
	}

	if( MyKFPawn.SpecialMoves.Length > MyKFPawn.SpecialMove )
	{
		curMove = MyKFPawn.SpecialMoves[MyKFPawn.SpecialMove];
	}
	else
	{
		curMove = none;
	}

    // Don't shoot if we're performing a special move that prevents it
    if( curMove != none && curMove.bDisablesWeaponFiring )
    {
        bMoveDisablesFiring = true;
    }

	Canvas = HUD.Canvas;
	Canvas.Font = class'Engine'.Static.GetTinyFont();
	Canvas.SetPos(Canvas.SizeX * 0.7f, Canvas.SizeY * 0.25f);

	Canvas.SetDrawColor(0,200,50);

    DrawDebugText( HUD, "Ranged Combat for "$string(MyKFPawn.Name));
    DrawDebugText( HUD, "--------------------------------------" );
    DrawDebugText( HUD, "Battle Phase: "$MyHansPawn.CurrentBattlePhase );
    DrawDebugText( HUD, "--Guns--" );
    DrawDebugText( HUD, "Guns Equipped: "$MyHansPawn.bGunsEquipped$" Can Use Guns In This Phase: "$MyHansPawn.CanUseGunsInThisPhase() );
    DrawDebugText( HUD, "Stance Changing: "$MyKFPawn.IsDoingSpecialMove(SM_ChangeStance)$" CurrentMove: "$curMove$" bDisablesWeaponFiring: "$bMoveDisablesFiring );

    if(`TimeSince(StartDrawGunsTime) > DrawGunFireDelay)
    {
        UsedDrawGunsCooldown = 0;
    }
    else
    {
        UsedDrawGunsCooldown = DrawGunFireDelay - `TimeSince(StartDrawGunsTime);
    }

    if(`TimeSince(LastAttackMoveFinishTime) > PostAttackMoveGunCooldown)
    {
        UsedAttackMoveGunsCooldown = 0;
    }
    else
    {
        UsedAttackMoveGunsCooldown = PostAttackMoveGunCooldown - `TimeSince(LastAttackMoveFinishTime);
    }

    if(`TimeSince(LastShotTime) > ShootingCooldown)
    {
        UsedShootCooldown = 0;
    }
    else
    {
        UsedShootCooldown = ShootingCooldown - `TimeSince(LastShotTime);
    }

    if(`TimeSince(StartGunAttackTime) > MaxGunAttackLength)
    {
        UsedGunAttackCooldown = 0;
    }
    else
    {
        UsedGunAttackCooldown = MaxGunAttackLength - `TimeSince(StartGunAttackTime);
    }

    if(`TimeSince(TimeFirstSawTarget) > TargetAquisitionDelay)
    {
        UsedGunTargetAquisitionCooldown = 0;
    }
    else
    {
        UsedGunTargetAquisitionCooldown = TargetAquisitionDelay - `TimeSince(TimeFirstSawTarget);
    }

    DrawDebugText( HUD, "Time Til We Can Shoot : "$UsedShootCooldown$" Time Til We Must Stop Shooting: "$UsedGunAttackCooldown, (UsedShootCooldown <= 0) ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255)  );
    DrawDebugText( HUD, "Draw Guns Delay Til We Can Shoot : "$UsedDrawGunsCooldown, (UsedDrawGunsCooldown <= 0) ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Attack Move Delay Til We Can Shoot : "$UsedAttackMoveGunsCooldown, (UsedAttackMoveGunsCooldown <= 0) ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Target Aquisition Delay Til We Can Shoot : "$UsedGunTargetAquisitionCooldown, (UsedGunTargetAquisitionCooldown <= 0) ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "FireTimer : "$GetRemainingTimeForTimer(nameof(FireTimer))$" StartFireTiming: "$GetRemainingTimeForTimer(nameof(StartFireTiming)), MakeColor(0,255,0,255));


    DrawDebugText( HUD, "--Grenades--" );
    DrawDebugText( HUD, "CurrentNadeAttackType: "$CurrentNadeAttackType$" IsThrowingGrenade: "$MyHansPawn.IsThrowingGrenade() );
    if( Enemy != none )
    {
        DrawDebugText( HUD, "Good Line Of Site: "$CanSeeByPoints( Pawn.GetPawnViewLocation(), Enemy.Location, Rotator(Enemy.Location - Pawn.GetPawnViewLocation()))$" Too Close To Regular Nade: "$IsWithinAttackRange() );
    }
    else
    {
        DrawDebugText( HUD, "Good Line Of Site: No Enemy, Too Close To Regular Nade: "$IsWithinAttackRange() );
    }

    if( MyHansPawn.LastOffensiveNadeTime == 0 || `TimeSince(MyHansPawn.LastOffensiveNadeTime) > MyHansPawn.GlobalOffensiveNadeCooldown )
    {
        UsedGlobalNadeAttackCooldown = 0;
    }
    else
    {
        UsedGlobalNadeAttackCooldown =  MyHansPawn.GlobalOffensiveNadeCooldown - `TimeSince(MyHansPawn.LastOffensiveNadeTime);
    }

    if( MyHansPawn.LastHENadeTossTime == 0 || `TimeSince(MyHansPawn.LastHENadeTossTime) > MyHansPawn.HENadeTossCooldown )
    {
        UsedHENadeTossCooldown = 0;
    }
    else
    {
        UsedHENadeTossCooldown =  MyHansPawn.HENadeTossCooldown - `TimeSince(MyHansPawn.LastHENadeTossTime);
    }

    if( MyHansPawn.LastHENadeBarrageTime ==0 || `TimeSince(MyHansPawn.LastHENadeBarrageTime) > MyHansPawn.HENadeBarrageCooldown )
    {
        UsedHENadeBarrageCooldown = 0;
    }
    else
    {
        UsedHENadeBarrageCooldown =  MyHansPawn.HENadeBarrageCooldown - `TimeSince(MyHansPawn.LastHENadeBarrageTime);
    }

    if( MyHansPawn.LastNerveGasTossTime ==0 || `TimeSince(MyHansPawn.LastNerveGasTossTime) > MyHansPawn.NerveGasTossCooldown )
    {
        UsedNerveGasTossCooldown = 0;
    }
    else
    {
        UsedNerveGasTossCooldown =  MyHansPawn.NerveGasTossCooldown - `TimeSince(MyHansPawn.LastNerveGasTossTime);
    }

    if( MyHansPawn.LastNerveGasBarrageTime ==0 || `TimeSince(MyHansPawn.LastNerveGasBarrageTime) > MyHansPawn.NerveGasBarrageCooldown )
    {
        UsedNerveGasBarrageCooldown = 0;
    }
    else
    {
        UsedNerveGasBarrageCooldown =  MyHansPawn.NerveGasBarrageCooldown - `TimeSince(MyHansPawn.LastNerveGasBarrageTime);
    }

    if( MyHansPawn.LastSmokeTossTime ==0 || `TimeSince(MyHansPawn.LastSmokeTossTime) > MyHansPawn.SmokeTossCooldown )
    {
        UsedSmokeTossCooldown = 0;
    }
    else
    {
        UsedSmokeTossCooldown =  MyHansPawn.SmokeTossCooldown - `TimeSince(MyHansPawn.LastSmokeTossTime);
    }

    DrawDebugText( HUD, "Global Nade Cooldown Complete: "$MyHansPawn.OffensiveGrenadeCooldownComplete()$" GlobalNadeAttackCooldown: "$UsedGlobalNadeAttackCooldown, MyHansPawn.OffensiveGrenadeCooldownComplete() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Can Smoke Toss: "$MyHansPawn.CanSmokeTossInThisPhase()$" SmokeTossCooldown: "$UsedSmokeTossCooldown, MyHansPawn.CanSmokeTossInThisPhase() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Can Nerve Gas Toss: "$MyHansPawn.CanTossNerveGasInThisPhase()$" NerveGasTossCooldown: "$UsedNerveGasTossCooldown, MyHansPawn.CanTossNerveGasInThisPhase() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Can HE Grenade Toss: "$MyHansPawn.CanTossGrenadeInThisPhase()$" HENadeTossCooldown: "$UsedHENadeTossCooldown, MyHansPawn.CanTossGrenadeInThisPhase() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Can Nerve Gas Barrage: "$MyHansPawn.CanBarrageNerveGasInThisPhase()$" NerveGasBarrageCooldown: "$UsedNerveGasBarrageCooldown, MyHansPawn.CanBarrageNerveGasInThisPhase() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );
    DrawDebugText( HUD, "Can HE Grenade Barrage: "$MyHansPawn.CanGrenadeBarrageInThisPhase()$" HENadeBarrageCooldown: "$UsedHENadeBarrageCooldown, MyHansPawn.CanGrenadeBarrageInThisPhase() ? MakeColor(0,255,0,255) : MakeColor(255,0,0,255) );

    DrawDebugText( HUD, "--RecentlySeenEnemyList--" );
	for( i = 0; i < RecentlySeenEnemyList.Length; i++ )
	{
        DrawDebugText( HUD, "TrackedEnemy #"$i$": "$RecentlySeenEnemyList[i].TrackedEnemy);
	    EyeLocation = MyKFPawn.Location + vect(0,0,1) * MyKFPawn.BaseEyeHeight;
        DrawDebugLine( EyeLocation, RecentlySeenEnemyList[i].LastVisibleLocation, 254, 89, 18, false );
	}
}


/*********************************************************************************************
* Grenades
**********************************************************************************************/

/** Return true if one of the standard (not smoke) grenade attack cooldowns is reached and we can attempt a nade throw*/
function bool GrenadeAttackInterruptGuns()
{
    // Don't interrupt the gun attack with the grenade attack if we just pulled the guns
    if( MyHansPawn.bGunsEquipped && `TimeSince(StartDrawGunsTime) < GrenadeGunInterruptDelay )
    {
        return false;
    }

    if( MyHansPawn.CanGrenadeBarrageInThisPhase() )
    {
        return true;
    }
    else if( MyHansPawn.CanBarrageNerveGasInThisPhase() )
    {
        return true;
    }
    else if( MyHansPawn.CanTossGrenadeInThisPhase() )
    {
        return true;
    }
    else if( MyHansPawn.CanTossNerveGasInThisPhase() )
    {
        return true;
    }

    return false;
}

/** Returns true if we can successfully set up a grenade attack */
function bool SetupGrenadeAttack()
{
	/** See if Hans can/should do a grenade attack right now*/
	if( MyHansPawn != none && Enemy != none && !MyHansPawn.IsDoingSpecialMove(SM_ChangeStance)
        && !MyHansPawn.IsThrowingGrenade() && !MyHansPawn.bGunsEquipped
        && CanSeeByPoints( Pawn.GetPawnViewLocation(), Enemy.Location, Rotator(Enemy.Location - Pawn.GetPawnViewLocation()) )
        && MyHansPawn.CacheGrenadeThrowLocation())
	{
        // Clear the last grenade attack type
        CurrentNadeAttackType = HNT_None;

        // Don't throw grenades up close, unless it's a smoke grenade during hunt and heal
        if( !IsWithinAttackRange() )
        {
            // Pick what kind of nade attack Hans should do
            if( MyHansPawn.CanGrenadeBarrageInThisPhase() )
            {
                CurrentNadeAttackType=HNT_HEGrenadeBarrage;
            }
            else if( MyHansPawn.CanBarrageNerveGasInThisPhase() )
            {
                CurrentNadeAttackType=HNT_NerveGasBarrage;
            }
            else if( MyHansPawn.CanTossGrenadeInThisPhase() )
            {
                CurrentNadeAttackType=HNT_HEGrenade;
            }
            else if( MyHansPawn.CanTossNerveGasInThisPhase() )
            {
                CurrentNadeAttackType=HNT_NerveGas;
            }
        }
        //Hans keeps tossing out smoke grenades occasionally when he's hunting a
        // player to heal from
        else
        {
            if( MyHansPawn.CanSmokeTossInThisPhase() )
            {
                CurrentNadeAttackType=HNT_Smoke;
            }
        }

        // Return true if we found a valid nade attack
        if( CurrentNadeAttackType != HNT_None )
        {
            return true;
        }
        else
        {
            return false;
        }
	}
	else
	{
	   return false;
	}
}

function DoStrike()
{
	local name AttackName;

	if( MyHansPawn != none && MyHansPawn.PawnAnimInfo != none )
	{
		AttackName = MyHansPawn.PawnAnimInfo.Attacks[PendingAnimStrikeIndex].Tag;

		// @todo: figure out a way to make this less hard-coded? (see also KFDialogManager::PlayHansKilledDialog)
		if( AttackName == 'Frenzy_Lunge' )
		{
			`DialogManager.PlayHansFrenzyDialog( MyHansPawn );
		}
        else if( AttackName == 'AOE' )
        {
            `DialogManager.PlayHansAOEDialog( MyHansPawn );
        }
	}

	super.DoStrike();
}

/**
 *  Used by movement commands to determine if NPC is close enough consider a strike
 *  Overridden so that Hans will move all the way to grab range and not get stuck.
 */
function bool IsWithinAttackRange()
{
	local float DistSqToEnemy;

    // Don't try to attack if our enemy isn't visible
    if( MyHansPawn == none || !bEnemyIsVisible )
    {
        return false;
    }

	// Don't grab players if you aren't in hunt and heal mode or are waiting for the smoke grenade barrage
    if( !MyHansPawn.bInHuntAndHealMode )
	{
	   return Super.IsWithinAttackRange();
	}

	// Check distance from enemy versus my grab range value.
	DistSqToEnemy = VSizeSq( Enemy.Location - Pawn.Location );
	if( DistSqToEnemy <= Square(MinDistanceToPerformGrabAttack) )
	{
		return true;
	}

	return false;
}

function bool CanAttackDestructibles()
{
    return !MyHansPawn.bGunsEquipped && bCanDoHeavyBump;
}

/*********************************************************************************************
* Battle-phase switching
**********************************************************************************************/

/** Overridden to handle door usage in flee state */
function NotifyAttackDoor( KFDoorActor Door )
{
    // We need to count up the total flee time so infinite fleeing isn't possible
    if( bFleeing )
    {
        TotalFleeTime = TotalFleeTime + (WorldInfo.TimeSeconds - FleeStartTime);
        bWantsToFlee = true;
        bFleeInterrupted = true;
        bFleeing = false;
        
        // Kill our flee and move commands
        AbortCommand( CommandList );

        // Allow melee again
        EnableMeleeRangeEventProbing();

        // Restart default command
        BeginCombatCommand( GetDefaultCommand(), "Restarting default command" );
    }

    super.NotifyAttackDoor( Door );
}

/** Overridden to handle door usage in flee state */
function bool DoorFinished()
{
    local bool bSuperFinished;

    bSuperFinished = super.DoorFinished();

    if( bWantsToFlee && !bFleeing )
    {
        if( MyHansPawn.IsDoingSpecialMove() )
        {
            MyHansPawn.EndSpecialMove();
        }
        Flee();
    }

    return bSuperFinished;
}

/**
 * Set Hans to the next phase in the battle
 */
function NextBattlePhase()
{
    // Set flee flags
    bHasFledThisPhase = false;
    MaxFleeDuration = RandRange( MinFleeDuration, MaxFleeDuration );
    bWantsToFlee = true;
    DisableMeleeRangeEventProbing();

    // Set smoke grenade barrage flag
    bHasUsedSmokeScreenThisPhase = false;
}

/** Whether enemy switch commands can be run */
function bool CanSwitchEnemies()
{
    return !bWantsToFlee && !bFleeing;
}

/* Starts Flee AICommand, with optional duration and distance */
function DoFleeFrom( actor FleeFrom,
    optional float FleeDuration,
    optional float FleeDistance,
    optional bool bShouldStopAtGoal=false,
    optional bool bFromFear=false,
	optional bool bUseRandomDirection=false )
{
    if( !bFromFear || !MyHansPawn.bInHuntAndHealMode )
    {
        super.DoFleeFrom( FleeFrom, FleeDuration, FleeDistance, bShouldStopAtGoal, bFromFear, bUseRandomDirection );
    }
}

/** Sets flee target if there is no enemy, starts flee command */
function Flee()
{
    local Actor FleeFromTarget;
    local float FleeDuration;
    local AICommand_SpecialMove AICSM;

    // Reset flee state
    bFleeing = false;
    bWantsToFlee = false;
    bFleeInterrupted = false;

    // We need a target to flee from
    Enemy = none;
    CheckForEnemiesInFOV( 3000.f, 0.2f, 1.f, true, false );
    if( Enemy == None )
    {
        SetEnemy( GetClosestEnemy() );
    }

    // Try to get an enemy, if not just choose a nearby navigation point (always flee!)
    if( Enemy != None )
    {
        FleeFromTarget = Enemy;
    }
    else
    {
        FleeFromTarget = class'NavigationPoint'.static.GetNearestNavToActor( MyHansPawn );
    }

    // Prevent timeout from interrupting flee
    AICSM = FindCommandOfClass( class'AICommand_SpecialMove' );
    if( AICSM != none )
    {
        AICSM.ClearTimeout();
    }

    // Abort all commands
    AbortCommand( CommandList );

    // Perform flee
    bFleeing = true;
    MyHansPawn.SetSprinting( true );
    DisableMeleeRangeEventProbing();

    FleeDuration = fMax( MaxFleeDuration - TotalFleeTime, 6.f );
    //`log("[FLEE] FleeDuration:"@FleeDuration);
    //`log("[FLEE] FleeStartTime:"@WorldInfo.TimeSeconds);
    FleeStartTime = WorldInfo.TimeSeconds;
    DoFleeFrom( FleeFromTarget, FleeDuration, MaxFleeDistance + Rand(MaxFleeDistance * 0.25f), true );
    EvaluateSprinting();

    // Constantly make sure we don't have a player trying to block us
    if( !IsTimerActive(nameOf(Timer_SearchForFleeObstructions)) )
    {
        SetTimer( 1.5f, false, nameOf(Timer_SearchForFleeObstructions) );
    }
}

/** Custom target searching when fleeing -- we only want to attack targets that are blocking our flee path */
function Timer_SearchForFleeObstructions()
{
    local KFPawn ObstructingEnemy;

    if( !bFleeing || bWantsToFlee || MyHansPawn.IsDoingSpecialMove() )
    {
        SetTimer( 0.25f, false, nameOf(Timer_SearchForFleeObstructions) );
        return;
    }

    // See if there's someone blocking us
    ObstructingEnemy = CheckForEnemiesInFOV( AttackRange * 1.1f, 0.5f, 1.f, false, false );
    if( ObstructingEnemy != none )
    {
        // We need to count up the total flee time so infinite fleeing isn't possible
        TotalFleeTime = TotalFleeTime + (WorldInfo.TimeSeconds - FleeStartTime);
        bFleeInterrupted = true;
        bFleeing = false;

        // Kill our flee and move commands
        AbortCommand( CommandList );

        // Set our new enemy
        ChangeEnemy( ObstructingEnemy, false );

        // Set our pending flee
        bWantsToFlee = true;

        // Sprint to new enemy
        MyHansPawn.SetSprinting( true );
        SetEnemyMoveGoal( self, true );
        EnableMeleeRangeEventProbing();

        // Restart default command
        BeginCombatCommand( GetDefaultCommand(), "Restarting default command" );

        // Give hans a little bit of time to flee after this attack
        SetTimer( 2.0f, false, nameOf(Timer_SearchForFleeObstructions) );
    }
    else
    {
        SetTimer( 0.25f, false, nameOf(Timer_SearchForFleeObstructions) );
    }
}


/** Command finished. Used to catch instances where the flee command is interrupted by another command */
function NotifyCommandFinished( AICommand FinishedCommand )
{
    if( !bWantsToFlee && bFleeing && PendingDoor == none && (ActorEnemy == none || ActorEnemy.bPendingDelete) && AICommand_Flee(FinishedCommand) != none )
    {
        // Add to our total flee time
        TotalFleeTime = TotalFleeTime + (WorldInfo.TimeSeconds - FleeStartTime);

        // Abort the flee command
        AbortCommand( FinishedCommand );

        // Cancel any special moves
        if( MyHansPawn.IsDoingSpecialMove() )
        {
            MyHansPawn.EndSpecialMove();
        }

        // Delay flee by a tiny bit to allow command to finish up
        SetTimer( 0.06f, false, nameOf(Flee), self );
    }
}

/** We have finished fleeing for one reason or another, notify pawn to heal */
function NotifyFleeFinished( optional bool bAcquireNewEnemy=true )
{
    local KFAISpawnManager SpawnManager;

    // Don't do additional cleanup if this wasn't a hunt and heal flee
    if( !MyHansPawn.bInHuntAndHealMode )
    {
        return;
    }

    // Restore flee flags to default
    bFleeing = false;
    bWantsToFlee = false;

    // Stop searching for targets
    ClearTimer( nameOf(Timer_SearchForFleeObstructions) );

    // Stop summoning minions
    SpawnManager = KFGameInfo(WorldInfo.Game).SpawnManager; 
    if( SpawnManager != none )
    {
        SpawnManager.StopSummoningBossMinions();
    }

    // Prevent infinite fleeing
    bHasFledThisPhase = true;

    // Find a new enemy and move to them
    if( bAcquireNewEnemy )
    {
        ChangeEnemy( GetClosestEnemy(), true );
    }

    // Allow melee again
    EnableMeleeRangeEventProbing();

    // Restart default command
    BeginCombatCommand( GetDefaultCommand(), "Restarting default command" );
}

/** Aborts the flee (shield was destroyed, etc) */
function CancelFlee( optional bool bAcquireNewEnemy=true )
{
    if( bFleeing )
    {
        bFleeing = false;
        bWantsToFlee = false;

        // Kill our flee command
        AbortCommand( FindCommandOfClass(class'AICommand_Flee') );

        // End flee as normal
        NotifyFleeFinished( bAcquireNewEnemy );
    }
    else
    {
        // Make sure hans doesn't try to flee again
        bWantsToFlee = false;
        bHasFledThisPhase = true;
    }
}

/**
 * Hans's prefers using health drain (grab) on players when he's wounded.  Currently he
 *	won't attempt this attack if he's already at full health
 */
event bool CanGrabAttack()
{
	local KFPawn KFPawnEnemy;
	local float DistSq;
	local vector HitLocation, HitNormal;
	local Actor HitActor;

    /** Don't try to grab while still fleeing */
    if( bFleeing || bWantsToFlee )
    {
        return false;
    }

	/** Hans shouldn't do this attack if at full health */
	if( Enemy == none || MyKFPawn == none || MyKFPawn.Health <= 0 || GetHealthPercentage() >= 1.f )
	{
		return false;
	}

	// Don't grab players if you aren't in hunt and heal mode or are waiting for the smoke grenade barrage
    if( MyHansPawn != none && (!MyHansPawn.bInHuntAndHealMode || MyHansPawn.bPendingSmokeGrenadeBarrage) )
	{
	   return false;
	}

	// If I'm dead, incapable of grabbing, or have no enemy, or my enemy is a player, or I'm busy doing a melee attack, refuse.
	if( (MyKFPawn == none || !MyKFPawn.bCanGrabAttack || MyKFPawn.Health <= 0) || (Enemy == none) || (Enemy != none && Pawn.IsSameTeam(Enemy)) )
	{
		return false;
	}

	KFPawnEnemy = KFPawn( Enemy );

	if( KFPawnEnemy != none && KFPawnEnemy.IsDoingSpecialMove(SM_GrappleVictim)
        && VSizeSq(MyHansPawn.Location - Enemy.Location) < Square(MinDistanceToPerformGrabAttack*1.5f) )
	{
        // End the move immediately so other zed stops grabbing our target!
        KFPawnEnemy.InteractionPawn.EndSpecialMove();
	}

	if( KFPawnEnemy == none || !KFPawnEnemy.CanBeGrabbed(MyKFPawn) )
	{
		return false;
	}

	// If I'm crippled, falling, busy doing an attack, or incapacitated, refuse.
	if( MyKFPawn.bIsHeadless || (MyKFPawn.Physics == PHYS_Falling) || IsDoingAttackSpecialMove() || MyKFPawn.IsImpaired() || MyKFPawn.IsIncapacitated() )
	{
		return false;
	}

	if( LastAttackTime_Grab == 0.f || (`TimeSince(LastAttackTime_Grab) > MinTimeBetweenGrabAttacks) )
	{
        // Make sure the enemy's center of mass (location) is within my collision cylinder
		if( Abs(Enemy.Location.Z - Pawn.Location.Z) > Pawn.CylinderComponent.CollisionHeight )
		{
			return false;
		}

		DistSq = VSizeSq(Enemy.Location - Pawn.Location);
		if( DistSq > Square(MinDistanceToPerformGrabAttack) )
		{
			return false;
		}
        // Do the same kind of trace we do in KFSM_GrappleStart
		HitActor = Trace(HitLocation, HitNormal, Enemy.Location, Pawn.Location, true);
		if ( HitActor != None && HitActor != Enemy )
		{
            return false;
		}
		if( !CanTargetBeGrabbed(KFPawn(Enemy)) )
		{
			return false;
		}
		/** Makes Zed have high desire to grab as initial attack */
		if( !MyKFPawn.IsDoingMeleeAttack() )
		{
			return true;
		}
	}
	`AILog( GetFuncName()$"() returning FALSE", 'GrabAttack' );
	return false;

}

function bool CanTargetBeGrabbed( KFPawn TargetKFP )
{
	local KFAIController OtherKFAIC;

	// Disallow if target is invalid, already being grabbed, or currently falling
	if( TargetKFP == none || (TargetKFP.Health <= 0) || (TargetKFP.IsDoingSpecialMove(SM_GrappleVictim)) || TargetKFP.Physics == PHYS_Falling )
	{
		return false;
	}

	// Need to check that no other clots are performing initial grab move on player since SM_GRAB is run without the player in a special move
	foreach WorldInfo.AllControllers( class'KFAIController', OtherKFAIC )
	{
		if( OtherKFAIC == self )
		{
			continue;
		}
		// If the the other Zed is doing a grab start or grab attack special move, and TargetKFP is also his enemy, disallow
		// this grab. Already checked if player is doing a grapplevictim special move above, but the player isn't executing
		// the victim special move until the other Zed's initial grab anim is complete (see KFSM_Clot_Grab - this is the move that determines
		// whether the clot's grab should miss or succeed based on when the initial sequence is interrupted)...  so instead check
		// whether the starting-to-grab Zed has the same enemy.
		// The grab special move assumes that the grab victim is also the grabber's enemy.
		if( OtherKFAIC.MyKFPawn != none && OtherKFAIC.Enemy == TargetKFP && OtherKFAIC.IsDoingGrabSpecialMove() )
		{
            if( VSizeSq(MyHansPawn.Location - TargetKFP.Location) < 250000 ) // 5 Meters
            {
                // End the move immediately so other zed stops grabbing our target!
                OtherKFAIC.MyKFPawn.EndSpecialMove();
            }
		}
	}

	return true;
}

/** Launch a grab attack */
event DoGrabAttack( optional Pawn NewEnemy, optional float InPostSpecialMoveSleepTime=0.f )
{
	if( CommandList == None || AICommand(CommandList).bAllowedToAttack )
	{
		if( NewEnemy != None && NewEnemy != Enemy )
		{
			ChangeEnemy( NewEnemy, false );
		}
		/** Abort qany movement commands */
		ClearMovementInfo();
		`AILog( GetFuncName()$"() Init AICommand_Attack_Grab", 'InitAICommand' );
		class'AICommand_Attack_Grab'.static.Grab( self, InPostSpecialMoveSleepTime );
	}
	else if( CommandList != none && !AICommand(CommandList).bAllowedToAttack )
	{
		`AILog( GetFuncName()$"() not doing grab attack because current command ("$CommandList$") will not allow it", 'GrabAttack' );
	}
}

/** Effects and damage from a zed sprinting and bumping other monsters */
function bool DoHeavyZedBump( Actor Other, vector HitNormal )
{
	local int BumpEffectDamage;
	local KFPawn_Monster BumpedMonster;

	/** If we bumped into a glass window, break it */
	if( Other.bCanBeDamaged && KFFracturedMeshGlass(Other) != none )
	{
		KFFracturedMeshGlass(Other).BreakOffAllFragments();
		return true;
	}

	BumpedMonster = KFPawn_Monster(Other);
	if( BumpedMonster == none || !BumpedMonster.IsAliveAndWell() || BumpedMonster.ZedBumpDamageScale <= 0 )
	{
		return false;
	}

	if( MyKFPawn == none || !MyKFPawn.IsAliveAndWell() )
	{
		return false;
	}

	// Hans knocks guys out of the way always if he is in hunt and heal
    if( (MyHansPawn.bInHuntAndHealMode && !IsZero(MyKFPawn.Velocity)) || (MyKFPawn.bIsSprinting && !MyKFPawn.IsDoingSpecialMove()) )
	{
		BumpEffectDamage = ZedBumpEffectThreshold * BumpedMonster.ZedBumpDamageScale;

		// If the Bumped Zed is near death, play either a knockdown or an immediate obliteration
		if( BumpedMonster.Health - BumpEffectDamage <= 0 )
		{
			// Chance to obliterate if at low health
			if( FRand() < ZedBumpObliterationEffectChance )
			{
				BumpedMonster.TakeDamage(BumpEffectDamage, self, BumpedMonster.Location, vect(0,0,0), MyKFPawn.GetBumpAttackDamageType());
			}
			else
			{
				BumpedMonster.Knockdown( , vect(1,1,1), Pawn.Location, 1000, 100 );
			}
			return true;
		}
		else
		{
			// otherwise deal damage and stumble the zed
			BumpedMonster.TakeDamage(BumpEffectDamage, self, BumpedMonster.Location, vect(0,0,0), MyKFPawn.GetBumpAttackDamageType());
			BumpedMonster.DoSpecialMove(SM_Stumble,,, class'KFSM_Stumble'.static.PackBodyHitSMFlags(BumpedMonster, HitNormal));
			return true;
		}
	}
	return false;
}

function bool CanDoStrike()
{
    local bool bInGrabRange;
    local float DistSq;

    if( !bFleeing && !bWantsToFlee )
    {
    	/** See if we want to grab an enemy, and they are in grab range */
    	if( Enemy != none && MyHansPawn != none && MyHansPawn.bInHuntAndHealMode &&
            MyKFPawn != none && MyKFPawn.Health > 0 )
    	{
        	DistSq = VSizeSq(Enemy.Location - Pawn.Location);
    		if( DistSq < Square(MinDistanceToPerformGrabAttack) )
    		{
                bInGrabRange = true;
    		}
    	}

    	// Never do melee strikes when in bInHuntAndHealMode unless we can't grab attack, and the enemy is in grab range
    	if( MyHansPawn == none || (MyHansPawn.bInHuntAndHealMode && (!bInGrabRange || CanGrabAttack())) )
    	{
    		return false;
    	}
    }

	return super.CanDoStrike();
}

event EdgeAndPolySubRegionRejectedDueToDist( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector SubRegionLocation, vector PolyCenterRejected, float Dist )
{
 	local KFDebugLines KFDL;

	if( class'KFGameEngine'.default.bEnableAdvDebugLines )
	{
//
 		KFDL = class'KFDebugLines'.static.GetDebugLines();
	//
 		KFDL.AddDebugSphere( SubRegionLocation, 32, 8, 255, 0, 0, true);
 		KFDL.AddDebugText3D( SubRegionLocation + vect(0,0,1) * 72.f, "FAILED DUE TO Dist:"$Dist, true, 100, 100, 0, true );

	}
}

event EdgeAndPolySubRegionRejectedDueToRating( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector SubRegionLocation, vector PolyCenterRejected, int Rating )
{
 	local KFDebugLines KFDL;
//
	if( class'KFGameEngine'.default.bEnableAdvDebugLines )
	{
 		KFDL = class'KFDebugLines'.static.GetDebugLines();
	//
 		KFDL.AddDebugSphere( SubRegionLocation, 32, 8, 255, 255, 0, true );
 		KFDL.AddDebugText3D( SubRegionLocation + vect(0,0,1) * 72.f, "FAILED DUE TO RATING:"$Rating, true, 100, 200, 0, true );
	}
}

event EntireEdgeAndPolyRejectedDueToRating( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector PolyCenterRejected, int Rating )
{
 	local KFDebugLines KFDL;
	local vector centerOfLineFromEdgeToPolyCenter;

	if( class'KFGameEngine'.default.bEnableAdvDebugLines )
	{
		centerOfLineFromEdgeToPolyCenter = 0.5 * (PolyCenterRejected - EdgeCenterRejected);
	//
 		KFDL = class'KFDebugLines'.static.GetDebugLines();
	//
 		//KFDL.AddDebugSphere( PossibleGoal.Location, 32, 8, 255, 255, 0, true );
		KFDL.AddDebugLine( EdgeCenterRejected, PolyCenterRejected, 255, 0, 0, true );
 		KFDL.AddDebugText3D( EdgeCenterRejected + centerOfLineFromEdgeToPolyCenter + vect(0,0,1) * 72.f, "Entire Edge FAILED DUE TO RATING:"$Rating, true, 100, 200, 0, true );

	}
}

event EdgeAndPolySubRegionRejectedDueToLOS( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector SubRegionLocation, vector PolyCenterRejected, vector HitLocation, Actor HitActor )
{
 	local KFDebugLines KFDL;

	if( class'KFGameEngine'.default.bEnableAdvDebugLines )
	{
	//
 		KFDL = class'KFDebugLines'.static.GetDebugLines();
	//
 		KFDL.AddDebugSphere( SubRegionLocation, 32, 8, 255, 0, 0, true );
 		KFDL.AddDebugText3D( SubRegionLocation+ vect(0,0,1) * 72.f, "FAILED DUE TO LOS", true, 100, 100, 0, true );

	}
}

event EdgeAndPolySubRegionRejectedDueToAdjustToss( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector SubRegionLocation, vector PolyCenterRejected, vector HitLocation )
{
 	local KFDebugLines KFDL;

	if( class'KFGameEngine'.default.bEnableAdvDebugLines )
	{
	//
 		KFDL = class'KFDebugLines'.static.GetDebugLines();
	//
 		KFDL.AddDebugSphere( SubRegionLocation, 32, 8, 255, 0, 0, true );
 		KFDL.AddDebugText3D( SubRegionLocation + vect(0,0,1) * 72.f, "FAILED DUE TO AdjustToss", true, 100, 100, 0, true );

	}
}

event EdgeAndPolySubRegionRejectedDueToProximityToTarget( vector EdgeCenterRejected, ENavmeshEdgeType EdgeTypeRecjted, Color EdgeTypeColorRejected, vector SubRegionLocation, vector PolyCenterRejected, float Range, Actor Target )
{
}

`if(`notdefined(ShippingPC))
/** Debug command to advance battle phase */
function DebugNextPhase()
{
    MyHansPawn.SetHuntAndHealMode( true );
    MyHansPawn.Health = MyHansPawn.HealthMax * 0.34;
}
`endif

/*********************************************************************************************
* Pathfinding
********************************************************************************************* */

function bool AmIAllowedToSuicideWhenStuck()
{
	return false;
}


function InitalizeBaseCommand( class<AICommand> CmdClass )
{

	CmdClass.static.InitCommand( self );
}

/*********************************************************************************************
* Dialog
********************************************************************************************* */

function NotifyKilled(Controller Killer, Controller Killed, pawn KilledPawn, class<DamageType> damageType)
{
	if( self == Killer )
	{
		`DialogManager.PlayHansKilledDialog( MyHansPawn, damageType );
	}
}

function PlayDamagePlayerDialog( class<DamageType> DmgType )
{
	`DialogManager.PlayHansDamagePlayerDialog( MyHansPawn, DmgType );
}

DefaultProperties
{
	Steering=none
	DefaultCommandClass=class'KFGame.AICommand_Base_Hans'
	MeleeCommandClass=class'KFGame.AICommand_Base_Hans'
    MinDistanceToPerformGrabAttack=350.f
    MinTimeBetweenGrabAttacks=2.5f
    bRepathOnInvalidStrike=true

	//DefaultBehavior="Hans_BT"
	//UsedETQQueries[ENQ_EnemySelection]="BaseZedEnemySelection"

    AggroEnemySwitchWaitTime=7.0f //7
    RetargetWaitTimeRange=(X=4.4, Y=5.0)  //(X=5.0, Y=7.0)  (X=5.0, Y=8.0)feels good but he finishs people off to much

	bCanDoHeavyBump=true
	LostSightSprintDelay=0.5

    StartShootingRange=4000
    MinShootingRange=300

    LostSightStopFireDelay=1.25
	BurstWaitTime=0.5
	MinBurstAmount=3
	MaxBurstAmount=8
	BarrageLength=3.0
	BarrageWaitTime=1.5
	GrenadeGunInterruptDelay=5.0

	BarrageWaitDistanceCurve=(Points=((InVal=0.f,OutVal=1.25f),(InVal=2500.0f, OutVal=1.f)))
	BurstWaitDistanceCurve=(Points=((InVal=0.f,OutVal=4.f),(InVal=2500.0f, OutVal=1.f)))

	TargetAquisitionDelay=0.25
	DrawGunFireDelay=1.0

	StanceChangeCooldown=0.3
	PostAttackMoveGunCooldown=0.3

	CurrentNadeAttackType=HNT_None
	GrenadeAttackEvalInterval=0.1
	LastRecentSeenEnemyListUpdateTime=0.1

    MinFleeDuration=5.f //10 //3 //2
    MaxFleeDuration=6.f //15  //5  //3
    MaxFleeDistance=3000.f //10000. //5000

	TeleportCooldown=15.0
	HiddenRelocateTeleportThreshold=12.0

    // ---------------------------------------------
    // Danger Evasion Settings
    DangerEvadeSettings.Empty

    DangerEvadeSettings(0)={(ClassName="KFProj_Bullet_Pellet",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.85, 0.95), //0.1, 0.3, 0.5, 0.6
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(1)={(ClassName="KFProj_Nail_Nailgun",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.85, 0.95),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(2)={(ClassName="KFProj_Bullet_DragonsBreath",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.85, 0.95),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(3)={(ClassName="KFProj_HighExplosive_M79",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(4)={(ClassName="KFProj_HighExplosive_M32",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(5)={(ClassName="KFProj_Rocket_RPG7",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(6)={(ClassName="KFDT_Explosive_M16M203",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(7)={(ClassName="KFDT_Explosive_HRGIncendiaryRifle",
                                Cooldowns=(4.0, 3.0, 2.0, 1.0), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}


    //shooting fire
    DangerEvadeSettings(8)={(ClassName="KFProj_CaulkNBurn_GroundFire",
                                Cooldowns=(3.0, 3.0, 2.5, 1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.0, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(9)={(ClassName="KFProj_FlameThrower_GroundFire",
                                Cooldowns=(3.0, 3.0, 2.5, 1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.0, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(10)={(ClassName="KFWeap_Flame_CaulkBurn",
                                Cooldowns=(3.0, 3.0, 2.5, 1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.0, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(11)={(ClassName="KFWeap_Flame_Flamethrower",
                                Cooldowns=(3.0, 3.0, 2.5, 1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(12)={(ClassName="KFWeap_Beam_Microwave",
                                Cooldowns=(3.0, 3.0, 2.5,  1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(13)={(ClassName="KFProj_Flame_HRGIncendiaryRifle",
                                Cooldowns=(3.0, 3.0, 2.5, 1.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.0, 0.3, 0.5, 0.8),
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.00))},
                                SoloChanceMultiplier=1.0)}

    //Aimed weapons it dodges //sharpshooter
    DangerEvadeSettings(14)={(ClassName="KFWeap_Bow_Crossbow",
                                Cooldowns=(2.3, 2.3, 2.3, 1.3), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.08, 0.1, 0.2, 0.35),
                                ForcedEvadeChances={((FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15))},
                                SoloChanceMultiplier=1.0)}  
    DangerEvadeSettings(15)={(ClassName="KFWeap_Bow_CompoundBow",
                                Cooldowns=(2.3, 2.3, 2.3, 1.3), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.08, 0.1, 0.2, 0.35),
                                ForcedEvadeChances={((FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(16)={(ClassName="KFWeap_Rifle_M14EBR",
                                Cooldowns=(2.3, 2.3, 2.3, 1.3), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.08, 0.1, 0.2, 0.35),
                                ForcedEvadeChances={((FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(17)={(ClassName="KFWeap_Rifle_Winchester1894",
                                Cooldowns=(2.3, 2.3, 2.3, 1.3), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.08, 0.1, 0.2, 0.35),
                                ForcedEvadeChances={((FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15))},
                                SoloChanceMultiplier=1.0)}
    DangerEvadeSettings(18)={(ClassName="KFWeap_Rifle_RailGun",
                                Cooldowns=(2.3, 2.3, 2.3, 1.3), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.08, 0.1, 0.2, 0.35),
                                ForcedEvadeChances={((FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15), (X=0.0, Y=0.15))},
                                SoloChanceMultiplier=1.0)}

    //Grenades
    DangerEvadeSettings(19)={(ClassName="KFProj_FragGrenade",
                                Cooldowns=(6.0, 5.0, 3.0, 2.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}  
    DangerEvadeSettings(20)={(ClassName="KFProj_MolotovGrenade",
                                Cooldowns=(6.0, 5.0, 3.0, 2.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}  
    DangerEvadeSettings(21)={(ClassName="KFProj_DynamiteGrenade",
                                Cooldowns=(6.0, 5.0, 3.0, 2.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}  
    DangerEvadeSettings(22)={(ClassName="KFProj_NailBombGrenade",
                                Cooldowns=(6.0, 5.0, 3.0, 2.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}  
    DangerEvadeSettings(23)={(ClassName="KFProj_HEGrenade",
                                Cooldowns=(6.0, 5.0, 3.0, 2.5), // Normal, Hard, Suicidal, HoE
                                EvadeChances=(0.1, 0.3, 0.5, 0.6),
                                ForcedEvadeChances={((FL=0.0, FR=0.0), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5), (FL=0.5, FR=0.5))},
                                ReactionDelayRanges={((X=0.0, Y=0.2), (X=0.0, Y=0.0), (X=0.0, Y=0.15), (X=0.0, Y=0.05))},
                                SoloChanceMultiplier=1.0)}

    //Aim Blocks
    DangerEvadeSettings(24)={(ClassName="KFWeap_Rifle_Winchester1894",
                                Cooldowns=(0.5, 0.4, 0.3, 0.2), // Normal, Hard, Suicidal, HoE
                                BlockChances=(0.1, 0.2, 0.7, 0.85))}
    DangerEvadeSettings(25)={(ClassName="KFWeap_Bow_Crossbow",
                                Cooldowns=(0.5, 0.4, 0.3, 0.2), // Normal, Hard, Suicidal, HoE
                                BlockChances=(0.1, 0.2, 0.7, 0.85))}
    DangerEvadeSettings(26)={(ClassName="KFWeap_Rifle_M14EBR",
                                Cooldowns=(0.5, 0.4, 0.3, 0.2), // Normal, Hard, Suicidal, HoE
                                BlockChances=(0.1, 0.2, 0.7, 0.85))}
    DangerEvadeSettings(27)={(ClassName="KFWeap_Rifle_RailGun",
                                Cooldowns=(0.5, 0.4, 0.3, 0.2), // Normal, Hard, Suicidal, HoE
                                BlockChances=(0.1, 0.2, 0.7, 0.85))}
    DangerEvadeSettings(28)={(ClassName="KFWeap_Bow_CompoundBow",
                                Cooldowns=(0.5, 0.4, 0.3, 0.2), // Normal, Hard, Suicidal, HoE
                                BlockChances=(0.1, 0.2, 0.7, 0.85))}   
}