USARBotAPI.RemoteBot

//=============================================================================
// RemoteBot.
// Basedon Bot class
//=============================================================================
class RemoteBot extends Bot
    config(USARBotAPI);


var config bool bDebug;
var config bool bSilentGamebot;

//maybe link to bot's periphreal vision? UT bots need much less of an arc though
//like Pawn's PeriphrealVision, this value should be the cosine of the limits
//of visual field. (i.e. 0.707 = 45 degrees to each side, or a 90* arc.)
var config float remoteVisionLimit;

//The socket to the agent
var BotConnection myConnection;


//The three remote vars compliment the my vars right below. The only one
//that ever needs to be duplicated is RemoteEnemy and myTarget
//just need RemoteDestination || myDestination and RFocus || myFocus

//Who the remote bot is trying to shoot at. Used by the aiming code.
var Actor RemoteEnemy;
//Thing the remote bot is trying to move to.
var Actor RemoteDestination;
//Thing the remote bot is looking at.
var Actor RemoteFocus;

//The spot the bot is shooting at
var vector myTarget;
//The spot the bot is moving to
var vector myDestination;
//The spot the bot is looking at
var vector myFocus;


var rotator myRotationRate;

// time that last sent a WAL message
var float lastWallHitTime;

// time that last sent a BMP message
var float lastBumpTime;




// delimeters for strings sent to clients. set to match those of myConnection
// as = identifies the start of an attribute
var string as;
// ae = attribute end
var string ae;
// ib = item break
var string ib;


var rotator myRotation;
var DeadReckoning botDR;
var bool isDR;
var config float deltatime;
var actor HitActor;
var vector HitNormal, HitLocation;
struct DRMovement {
    var float DR_T;
    
    var vector DR_P;
    var vector DR_V;
    var vector DR_A;

    var rotator DR_RP;
    var rotator DR_RV;
    var rotator DR_RA;
    
    var int PreK;
    var bool bLFilter;
    var bool bRFilter;
};
var DRMovement start;

// called when using movetoward with bAdvancedTactics true to temporarily modify destination
event AlterDestination();

// Mover has notifies pawn that pawn is underneath it
function UnderLift(Mover M)
{
    // SENDMESSAGE
    // !!! possible new message
}

//Take a wild guess
function StartMatch()
{
    // SENDMESSAGE
    // !!! possible new message
}

//Called from weapon code when out of ammo or some such
//Don't call from local - weapon won't stop until ticked
function StopFiring()
{
    bFire = 0;
    bAltFire = 0;
}

//Use from local code - stops firing and ticks weapon to let it stop 
function HaltFiring()
{
    Pawn.Weapon.StopFire(Pawn.Weapon.BotMode);
    StopFiring();
    Pawn.Weapon.Tick(0.001);
}





//Change to what the bot is standing on
singular event BaseChange()
{
    // !!! Can't handle shootable floors
    /*
    local actor HitActor;
    local vector HitNormal, HitLocation;
    if ( Mover(Base) != None )
    {
        // handle shootable secret floors
        if ( Mover(Base).bDamageTriggered && !Mover(Base).bOpening
            && (MoveTarget != None) )
        {
            HitActor = Trace(HitLocation, HitNormal, MoveTarget.Location, Location, true);
            if ( HitActor == Base )
            {
                Target = Base;
                bShootSpecial = true;
                FireWeapon();
                bFire = 0;
                bAltFire = 0;
                Base.Trigger(Base, Self);
                bShootSpecial = false;
            }
        }
    }
    else */
        botDR.SetT(Level.TimeSeconds);// Added by jjwang. When the bot changes its base, refreshs the DR. 02/28/03
        Super(Pawn).BaseChange();

    // !!! possible SENDMESSAGE
}




//Called right before bot falls off something
//If bot running, set bCanJump to true - let him fall
//if walking, won't fall
event MayFall()
{   
    local bool bFall;
    
    bFall = !Pawn.bIsWalking;
    
    if(!bfall)
    {
        GotoState('Startup', 'Begin');
    }
    
    if (!bSilentGamebot) 
        myConnection.SendLine("FAL" $ib$as$ "Fell" $ib$ bFall $ae$ib$as$"Location" $ib$ Location $ae);
                            
    Pawn.bCanJump = bFall;
}

function float GetSpeed()
{
    if(Pawn.bIsWalking)
    {
        return Pawn.WalkingPct;
    }
    else
    {
        return 1.0;
    }
}





//can be autocalled when bot is shot by team mate
function YellAt(Pawn Moron);





//called when get new item
function bool AddInventory( inventory NewItem )
{
    local bool res;
    res = Super(Pawn).AddInventory(NewItem);
    if (!bSilentGamebot)
        myConnection.SendLine("AIN" $ib$as$ "Id" $ib$ NewItem $ae$ib$as$"Class" $ib$ NewItem.Class $ae);
    return res;
}





// !!! need functions to send arbitrary string messages

//functions to send tokenized messages
function SendTeamMessage(PlayerReplicationInfo Recipient, name MessageType, byte MessageID, float Wait)
{
    //log(self@"Send message"@MessageType@MessageID@"at"@Level.TimeSeconds);
    if ( (MessageType == OldMessageType) && (MessageID == OldMessageID)
        && (Level.TimeSeconds - OldMessageTime < Wait) )
        return;

    //log("Passed filter");
    OldMessageID = MessageID;
    OldMessageType = MessageType;

    SendVoiceMessage(PlayerReplicationInfo, Recipient, MessageType, MessageID, 'TEAM');
}

function SendGlobalMessage(PlayerReplicationInfo Recipient, name MessageType, byte MessageID, float Wait)
{
    //log(self@"Send message"@MessageType@MessageID@"at"@Level.TimeSeconds);
    if ( (MessageType == OldMessageType) && (MessageID == OldMessageID) 
        && (Level.TimeSeconds - OldMessageTime < Wait) )
        return;

    //log("Passed filter");
    OldMessageID = MessageID;
    OldMessageType = MessageType;

    SendVoiceMessage(PlayerReplicationInfo, Recipient, MessageType, MessageID, 'GLOBAL');
}




//events for recieving arbitrary string messages
event ClientMessage( coerce string S, optional name Type, optional bool bBeep )
{
    if (!bSilentGamebot) myConnection.SendLine("VMS" $ib$as$ "String" $ib$ S $ae);
}
event TeamMessage( PlayerReplicationInfo PRI, coerce string S, name Type, optional bool bBeep )
{
    if (!bSilentGamebot) myConnection.SendLine("VMT" $ib$as$ "String" $ib$ S $ae);
}





//events for recieving tokenized voice message
function BotVoiceMessage(name messagetype, byte MessageID, Controller Sender)
{
    if (Sender.PlayerReplicationInfo.Team != PlayerReplicationInfo.Team)
        return;

    if (!bSilentGamebot)
        myConnection.SendLine("VMG" $ib$as$ "Sender" $ib$ Sender $ae$ib$as$"Type" $ib$ messagetype $ae$ib$as$ 
                              "Id" $ib$ messageID $ae);
}




//other code may try to call this. make sure nada happens
//!!! need to change - make sure orders are actually recorded somewhere
//             for reference
function SetOrders(name NewOrders, Controller OrderGiver);







/*
// !!! Allow for disabling of autoswitch???
function bool SwitchToBestWeapon()
{
    local float rating;
    local int usealt, favalt;
    local inventory MyFav;

    if ( Inventory == None )
        return false;

    PendingWeapon = Inventory.RecommendWeapon(rating, usealt);
    if ( PendingWeapon == None )
        return false;

    if ( (FavoriteWeapon != None) && (PendingWeapon.class != FavoriteWeapon) )
    {
        MyFav = FindInventoryType(FavoriteWeapon);
        if ( (MyFav != None) && (Weapon(MyFav).RateSelf(favalt) + 0.22 > PendingWeapon.RateSelf(usealt)) )
        {
            usealt = favalt;
            PendingWeapon = Weapon(MyFav);
        }
    }
    if ( Weapon == None )
        ChangedWeapon();
    else if ( Weapon != PendingWeapon )
        Weapon.PutDown();

    return (usealt > 0);
}
*/







//events that are called when head, feet or whole bot changes zones
//e.g. air to water or lava
//only way to tell if underwater until drowning damage starts
/*function FootZoneChange(ZoneInfo newFootZone)
{
    Super.FootZoneChange(newFootZone);

    if (!bSilentGamebot) myConnection.SendLine("ZCF" $ib$as$ "Id" $ib$ newFootZone $ae);
}
function HeadZoneChange(ZoneInfo newHeadZone)
{
    Super.HeadZoneChange(newHeadZone);

    if (!bSilentGamebot) myConnection.SendLine("ZCH" $ib$as$ "Id" $ib$ newHeadZone $ae);
}*/
function ZoneChange(ZoneInfo newZone)
{
    Super.ZoneChange(newZone);

    if(myConnection != None && !bSilentGamebot)
        myConnection.SendLine("ZCB" $ib$as$ "Id" $ib$ newZone $ae);
}








//may want to hack into this for vision limits.
//used by existing bots to change fov based on activity.
/*function SetPeripheralVision()
{
    if ( bNovice )
        PeripheralVision = 0.7;
    else if ( Skill == 3 )
        PeripheralVision = -0.2;
    else
        PeripheralVision = 0.65 - 0.33 * skill;

    PeripheralVision = FMin(PeripheralVision - BaseAlertness, 0.9);

    Pawn.SightRadius = Pawn.Default.SightRadius;
}*/






//overriden to avoid bot version which can goto state 'findair'
function PainTimer()
{
    if (Pawn.Health <= 0)
        return;

    /*if (FootRegion.Zone.bPainZone)
        Super(Pawn).PainTimer();
    else if (HeadRegion.Zone.bWaterZone)
    {
        if (bDrowning)
            self.TakeDamage(5, None, Location + CollisionHeight * vect(0,0,0.5), vect(0,0,0), 'Drowned');
        
        if (Pawn.Health > 0)
            PainTime = 2.0;
    } */ // FIXME
}   








//Called when weapon is switched - may happen automatically
function ChangedWeapon()
{
    if ( Pawn.Weapon != None && Pawn.Weapon == Pawn.PendingWeapon )
    {
            SwitchToBestWeapon();
        if ( Pawn.Weapon.GetStateName() == 'DownWeapon' ) 
            Pawn.Weapon.GotoState('Idle');
        Pawn.PendingWeapon = None;
    }
    else
        Super(Pawn).ChangedWeapon();

    if ( Pawn.Weapon != None )
    {
        if (bFire > 0)
        {
            bAltFire = 0;
            bFire = 1;
            Pawn.weapon.Fire(1.0);
        }
        else if (bAltFire > 0)
        {
            bAltFire = 0;
            bFire = 1;
            Pawn.Weapon.AltFire(1.0);
        }
        Pawn.Weapon.SetHand(0);
        // Weapon.FireOffset.Y = 0;
    }
    // !!! use or just make people get from status update
    if (!bSilentGamebot) {
        if(Pawn.Weapon == None)
            myConnection.SendLine("CWP" $ib$as$ "Id" $ib$ "None" $ae$ib$as$"Class" $ib$ "None" $ae);
        else 
            myConnection.SendLine("CWP" $ib$as$ "Id" $ib$ Pawn.Weapon $ae$ib$as$"Class" $ib$ Pawn.Weapon.Class $ae);
    }
}








// called from pathnodes that unitelligent creatures are supposed to avoid
function FearThisSpot(AvoidMarker aSpot);




event Touch( Actor Other )
{
    if (!bSilentGamebot) myConnection.SendLine("Touched " $Other);
}


//called on hitting a wall
event bool NotifyHitWall(vector HitNormal, actor HitActor)
{
    if ( Level.TimeSeconds - 0.5 >= lastWallHitTime ) 
    { 
        if (!bSilentGamebot)
            myConnection.SendLine("WAL" $ib$as$ "Id" $ib$ HitActor $ae$ib$as$"Normal" $ib$ HitNormal $ae$ib$as$ 
                                  "Location" $ib$ Location $ae);
            
        lastWallHitTime = Level.TimeSeconds;
    }   
    return true;
}

//called on collisions with other actors
event bool NotifyBump(Actor Other)
{
    local vector VelDir, OtherDir;
    local float speed;

    if ( TimerRate <= 0 )
        setTimer(1.0, false);

    speed = VSize(Velocity);
    if ( speed > 10 )
    {
        VelDir = Velocity/speed;
        VelDir.Z = 0;
        OtherDir = Other.Location - Location;
        OtherDir.Z = 0;
        OtherDir = Normal(OtherDir);
        if ( (VelDir Dot OtherDir) > 0.8 )
        {
            Velocity.X = VelDir.Y;
            Velocity.Y = -1 * VelDir.X;
            Velocity *= FMax(speed, 280);
        }
    }

    if ( Level.TimeSeconds - 0.5 >= lastBumpTime ) 
    { 
        if (!bSilentGamebot)
            myConnection.SendLine("BMP" $ib$as$ "Id" $ib$ Other $ae$ib$as$"Location" $ib$ Other.Location $ae);
            
        lastBumpTime = Level.TimeSeconds;
    }

    // Need to disable bumping ???
    //Disable('Bump');
    Disable('NotifyBump');
    return false;
}






function SetFall()
{
    //SENDMESSAGE
/*
    if (Enemy != None)
    {
        TweenToFalling();
        NextAnim = AnimSequence;
        GotoState('FallingState');
    }*/ // FIXME
}




function LongFall()
{
    // SENDMESSAGE ???
}

//called when someone picksup a nearby object WORKING????
function HearPickup(Pawn Other)
{
    if (!bSilentGamebot)
        myConnection.SendLine("HRP" $ib$as$"Rotation" $ib$ rotator(Location - Other.Location) $ae);
}

//called when sound is made
function HearNoise(float Loudness, Actor NoiseMaker)
{
    if (!bSilentGamebot)
        myConnection.SendLine("HRN" $ib$as$"SourceClass" $ib$ NoiseMaker.Class $ae$ib$as$"Rotation" $ib$ rotator(Location - NoiseMaker.Location) $ae);
}

//called periodicaly for each player in view
function SeePlayer(Pawn SeenPlayer)
{
    if(SeenPlayer == None) {
    return;
    }

    if (!bSilentGamebot)
        myConnection.SendLine("SEE" $ib$as$ "Id" $ib$ SeenPlayer $ae$ib$as$
                              "Rotation" $ib$ SeenPlayer.Rotation $ae$ib$as$ 
                              "Location" $ib$ SeenPlayer.Location $ae$ib$as$ 
                              "Velocity" $ib$ SeenPlayer.Velocity $ae$ib$as$
                              "Name" $ib$ SeenPlayer.PlayerReplicationInfo.PlayerName $ae$ib$as$
                              "Team" $ib$ SeenPlayer.PlayerReplicationInfo.Team $ae$ib$as$ 
                              "Reachable" $ib$ actorReachable(SeenPlayer) $ae$ib$as$ 
                              "Weapon" $ib$ SeenPlayer.Weapon $ae);
}






/* FindBestPathToward() assumes the desired destination is not directly reachable,
given the creature's intelligence, it tries to set Destination to the location of the
best waypoint, and returns true if successful
*/
/*
function bool FindBestPathToward(actor desired, bool bClearPaths)
{
    local Actor path;
    local bool success;

    if ( specialGoal != None)
        desired = specialGoal;
    path = None;
    path = FindPathToward(desired,,bClearPaths);

    success = (path != None);
    if (success)
    {
        MoveTarget = path;
        Destination = path.Location;
    }
    return success;
}
*/




/* NearWall() returns true if there is a nearby barrier at eyeheight, and
changes Focus to a suggested value
*/
//Potentially usefull
/*
function bool NearWall(float walldist)
{
    local actor HitActor;
    local vector HitLocation, HitNormal, ViewSpot, ViewDist, LookDir;

    LookDir = vector(Rotation);
    ViewSpot = Location + BaseEyeHeight * vect(0,0,1);
    ViewDist = LookDir * walldist;
    HitActor = Trace(HitLocation, HitNormal, ViewSpot + ViewDist, ViewSpot, false);
    if ( HitActor == None )
        return false;

    ViewDist = Normal(HitNormal Cross vect(0,0,1)) * walldist;
    if (FRand() < 0.5)
        ViewDist *= -1;

    if ( FastTrace(ViewSpot + ViewDist, ViewSpot) )
    {
        Focus = Location + ViewDist;
        return true;
    }

    ViewDist *= -1;

    if ( FastTrace(ViewSpot + ViewDist, ViewSpot) )
    {
        Focus = Location + ViewDist;
        return true;
    }

    Focus = Location - LookDir * 300;
    return true;
}
*/




// Largely untested
function RemoteJump()
{
  Pawn.DoJump(true);
}






//Intercept FireWeapon - is called from other code
function FireWeapon();

function RemoteFireWeapon(bool bUseAltMode)
{
    if ( !bUseAltMode )
    {
        bFire = 1;
        bAltFire = 0;
        Pawn.Weapon.BotMode = 0;
        Pawn.Weapon.StartFire(0);
    }
    else
    {
        bFire = 0;
        bAltFire = 1;
        Pawn.Weapon.BotMode = 1;
        Pawn.Weapon.StartFire(1);
    }
}






// check for line of sight to target deltatime from now.
//used by missle launcher and others to abort firing
// may want to reimplement
function bool CheckFutureSight(float deltatime)
{
    return true;
}





/*
Adjust the aim at target.
    - add aim error
    - adjust up or down if barrier
Must set RemoteTarget elsewhere
*/

function vector AdjustToss(float projSpeed, vector projStart, vector End, bool bNormalize)
{
    local vector FireSpot;
    local float TargetDist;
    local pawn RemoteTarget;

    RemoteTarget = pawn(RemoteEnemy);

    //if ( projSpeed == 0 )
    //    return AdjustAim(projSpeed, projStart, aimerror, leadTarget, warnTarget);
    if ( RemoteTarget == None || !FastTrace(RemoteTarget.Location) || !inFront(RemoteTarget.Location) )
        return vector(Pawn.Rotation);
    FireSpot = RemoteTarget.Location;
    TargetDist = VSize(RemoteTarget.Location - ProjStart);

    /*if ( !RemoteTarget.bIsPawn )
    //{
        if ( (Region.Zone.ZoneGravity.Z != Region.Zone.Default.ZoneGravity.Z)
            || (TargetDist > projSpeed) )
        {
            TossTime = TargetDist/projSpeed;
            FireSpot.Z -= ((0.25 * Region.Zone.ZoneGravity.Z * TossTime + 200) * TossTime + 60);
        }
        viewRotation = Rotator(FireSpot - ProjStart);
        return viewRotation;
    } 
    aimerror = aimerror * (11 - 10 *
        ((RemoteTarget.Location - Location)/TargetDist
            Dot Normal((RemoteTarget.Location + 1.2 * RemoteTarget.Velocity) - (ProjStart + Velocity))));

    if ( bNovice )
    {
        if ( (RemoteTarget.Weapon == None) || !RemoteTarget.Weapon.bMeleeWeapon || (TargetDist > 650) )
            aimerror = aimerror * (2.1 - 0.2 * (skill + FRand()));
        else
            aimerror *= 0.75;
        if ( Level.TimeSeconds - LastPainTime < 0.15 )
            aimerror *= 1.3;
    }
    else
    {
        aimerror = aimerror * (1.5 - 0.35 * (skill + FRand()));
        if ( (Skill < 2) && (Level.TimeSeconds - LastPainTime < 0.15) )
            aimerror *= 1.2;
    }
    if ( (bNovice && (LastAcquireTime > Level.TimeSeconds - 5 + 0.6 * Skill))
        || (LastAcquireTime > Level.TimeSeconds - 2.5 + Skill) )
    {
        LastAcquireTime = Level.TimeSeconds - 5;
        aimerror *= 1.75;
    }

    if ( !leadTarget || (accuracy < 0) )
        aimerror -= aimerror * accuracy;

    if ( leadTarget )
    {
        FireSpot += FMin(1, 0.7 + 0.6 * FRand()) * (Target.Velocity * TargetDist/projSpeed);
        if ( !FastTrace(FireSpot, ProjStart) )
            FireSpot = 0.5 * (FireSpot + RemoteTarget.Location);
    }

    //try middle
    FireSpot.Z = RemoteTarget.Location.Z;

    if ( !FastTrace(FireSpot, ProjStart) )
    {
        FireSpot = LastSeenPos;
        HitActor = Trace(HitLocation, HitNormal, FireSpot, ProjStart, false);
        if ( HitActor != None )
        {
            bFire = 0;
            bAltFire = 0;
            FireSpot += 2 * RemoteTarget.CollisionHeight * HitNormal;
            SetTimer(TimeBetweenAttacks, false);
        }
    }

    // adjust for toss distance (assume 200 z velocity add & 60 init height)
    if ( FRand() < 0.75 )
    {
        TossSpeed = projSpeed + 0.4 * VSize(Velocity);
        if ( (Region.Zone.ZoneGravity.Z != Region.Zone.Default.ZoneGravity.Z)
            || (TargetDist > TossSpeed) )
        {
            TossTime = TargetDist/TossSpeed;
            FireSpot.Z -= ((0.25 * Region.Zone.ZoneGravity.Z * TossTime + 200) * TossTime + 60);    
        }
    }

    FireRotation = Rotator(FireSpot - ProjStart);
    realYaw = FireRotation.Yaw;
    aimerror = Rand(2 * aimerror) - aimerror;
    FireRotation.Yaw = (FireRotation.Yaw + aimerror) & 65535;

    if ( (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) > 8192)
        && (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) < 57343) )
    {
        if ( (FireRotation.Yaw > Rotation.Yaw + 32768) || 
            ((FireRotation.Yaw < Rotation.Yaw) && (FireRotation.Yaw > Rotation.Yaw - 32768)) )
            FireRotation.Yaw = Rotation.Yaw - 8192;
        else
            FireRotation.Yaw = Rotation.Yaw + 8192;
    }
    FireDir = vector(FireRotation);
    // avoid shooting into wall
    HitActor = Trace(HitLocation, HitNormal, ProjStart + FMin(VSize(FireSpot-ProjStart), 400) * FireDir, ProjStart, false);
    if ( (HitActor != None) && (HitNormal.Z < 0.7) )
    {
        FireRotation.Yaw = (realYaw - aimerror) & 65535;
        if ( (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) > 8192)
            && (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) < 57343) )
        {
            if ( (FireRotation.Yaw > Rotation.Yaw + 32768) ||
                ((FireRotation.Yaw < Rotation.Yaw) && (FireRotation.Yaw > Rotation.Yaw - 32768)) )
                FireRotation.Yaw = Rotation.Yaw - 8192;
            else
                FireRotation.Yaw = Rotation.Yaw + 8192;
        }
        FireDir = vector(FireRotation);
    }

    if ( warnTarget && (RemoteTarget != None) )
        RemoteTarget.WarnTarget(self, projSpeed, FireDir);

    viewRotation = FireRotation;*/
    //return FireRotation;
}

function rotator AdjustAim(FireProperties FiredAmmunition, vector projStart, int aimerror)
{
    local rotator FireRotation;
    local vector FireSpot;
    local float TargetDist;
    local bool bDefendMelee;

    local pawn RemoteTarget;

    RemoteTarget = pawn(RemoteEnemy);

    if ( RemoteTarget == None )
    {
        bFire = 0;
        bAltFire = 0;
        return Rotation;
    }
    
    if ( !FastTrace(RemoteTarget.Location) || !inFront(RemoteTarget.Location) )
    {
        return Rotation;
    }
    
    //if ( !RemoteTarget.bIsPawn || RemoteTarget.IsA('FortStandard') )
    if ( RemoteTarget.IsA('FortStandard') )
        return rotator(RemoteTarget.Location - projstart);

    FireSpot = RemoteTarget.Location;
    TargetDist = VSize(RemoteTarget.Location - Location);

    aimerror = aimerror * (11 - 10 *
        ((RemoteTarget.Location - Location)/TargetDist
            Dot Normal((RemoteTarget.Location + 1.25 * RemoteTarget.Velocity) - (Location + Velocity))));

    bDefendMelee = ( (RemoteTarget.Weapon != None) && RemoteTarget.Weapon.bMeleeWeapon && (TargetDist < 700) );
    if ( bDefendMelee )
        aimerror *= 0.5;
    /*if ( ((projSpeed == 0) || (Projspeed >= 1000000)) )
    {
        // instant hit
        if ( bNovice )
            aimerror *= 0.5;
        else
            aimerror *= 0.5 + 0.19 * skill;
    }

    if ( bNovice )
    {
        if ( !bDefendMelee )
            aimerror = aimerror * (2.4 - 0.2 * (skill + FRand()));
        if ( (Level.TimeSeconds - LastPainTime < 0.2) || (Physics == PHYS_Falling) || (RemoteTarget.Physics == PHYS_Falling) )
            aimerror *= 1.5;
    }
    else
    {
        aimerror = aimerror * (1.7 - 0.4 * (skill + FRand()));
        if ( (Skill < 2) 
            && ((Level.TimeSeconds - LastPainTime < 0.15) || (Physics == PHYS_Falling) || (RemoteTarget.Physics == PHYS_Falling)) )
            aimerror *= 1.2;
    }

    if ( (bNovice && (LastAcquireTime > Level.TimeSeconds - 5 + 0.5 * skill))
        || (LastAcquireTime > Level.TimeSeconds - 2.5 + skill) )
    {
        LastAcquireTime = Level.TimeSeconds - 5;
        if ( bDefendMelee )
            aimerror *= 1.3;
        else
            aimerror *= 2;
    }

    if ( !leadTarget || (accuracy < 0) )
        aimerror -= aimerror * accuracy;

    if (leadTarget && (projSpeed > 0))
    {
        TargetVel = RemoteTarget.Velocity;
        if ( RemoteTarget.Physics == PHYS_Falling )
        {
            if ( RemoteTarget.Region.Zone.ZoneGravity == RemoteTarget.Region.Zone.Default.ZoneGravity )
                TargetVel.Z = FMin(-160, TargetVel.Z);
            else
                TargetVel.Z = FMin(0, TargetVel.Z);
        }
        FireSpot += FMin(1, 0.7 + 0.6 * FRand()) * TargetVel * TargetDist/projSpeed;
        FireSpot.Z = FMin(RemoteTarget.Location.Z, FireSpot.Z);
        if ( (RemoteTarget.Physics != PHYS_Falling) && (FRand() < 0.55) && (VSize(FireSpot - ProjStart) > 1000) )
        {
            TargetLook = RemoteTarget.Rotation;
            if ( RemoteTarget.Physics == PHYS_Walking )
                TargetLook.Pitch = 0;
            if ( ((Vector(TargetLook) Dot Normal(RemoteTarget.Velocity)) < 0.71) )
                bClean = false;
            else
                bClean = FastTrace(FireSpot, ProjStart);
        }
        else
            bClean = FastTrace(FireSpot, ProjStart);
        if ( !bClean)
        {
            if ( FRand() < 0.3 )
                FireSpot = RemoteTarget.Location;
            else
                FireSpot = 0.5 * (FireSpot + RemoteTarget.Location);
        }
    }

    bClean = false; //so will fail first check unless shooting at feet
    //if ( RemoteTarget.bIsPawn && (!bNovice || bDefendMelee)
    if ( bNovice || bDefendMelee)
        && (Weapon != None)
        && (Weapon.bRecommendSplashDamage || (Weapon.bRecommendAltSplashDamage && (bAltFire != 0))) 
        && (((RemoteTarget.Physics == PHYS_Falling) && (Location.Z + 80 >= RemoteTarget.Location.Z))
            || ((Location.Z + 19 >= RemoteTarget.Location.Z) && (bDefendMelee || (skill > 2.5 * FRand() - 0.5)))) )
    {
        HitActor = Trace(HitLocation, HitNormal, FireSpot - vect(0,0,1) * (RemoteTarget.CollisionHeight + 6), FireSpot, false);
        bClean = (HitActor == None);
        if ( !bClean )
        {
            FireSpot = HitLocation + vect(0,0,3);
            bClean = FastTrace(FireSpot, ProjStart);
        }
        else if ( RemoteTarget.Physics == PHYS_Falling )
            bClean = FastTrace(FireSpot, ProjStart);
        else
            bClean = false;
    }
    if ( !bClean )
    {
        //try middle
        FireSpot.Z = RemoteTarget.Location.Z;
        bClean = FastTrace(FireSpot, ProjStart);
    }
    if( !bClean ) 
    {
////try head
        FireSpot.Z = RemoteTarget.Location.Z + 0.9 * RemoteTarget.CollisionHeight;
        bClean = FastTrace(FireSpot, ProjStart);
    }

    FireRotation = Rotator(FireSpot - ProjStart);
    realYaw = FireRotation.Yaw;
    aimerror = Rand(2 * aimerror) - aimerror;
    FireRotation.Yaw = (FireRotation.Yaw + aimerror) & 65535;

    if ( (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) > 8192)
        && (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) < 57343) )
    {
        if ( (FireRotation.Yaw > Rotation.Yaw + 32768) || 
            ((FireRotation.Yaw < Rotation.Yaw) && (FireRotation.Yaw > Rotation.Yaw - 32768)) )
            FireRotation.Yaw = Rotation.Yaw - 8192;
        else
            FireRotation.Yaw = Rotation.Yaw + 8192;
    }
    FireDir = vector(FireRotation);
    // avoid shooting into wall
    FireDist = FMin(VSize(FireSpot-ProjStart), 400);
    FireSpot = ProjStart + FireDist * FireDir;
    HitActor = Trace(HitLocation, HitNormal, FireSpot, ProjStart, false); 
    if ( HitActor != None )
    {
        if ( HitNormal.Z < 0.7 )
        {
            FireRotation.Yaw = (realYaw - aimerror) & 65535;
            if ( (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) > 8192)
                && (Abs(FireRotation.Yaw - (Rotation.Yaw & 65535)) < 57343) )
            {
                if ( (FireRotation.Yaw > Rotation.Yaw + 32768) ||
                    ((FireRotation.Yaw < Rotation.Yaw) && (FireRotation.Yaw > Rotation.Yaw - 32768)) )
                    FireRotation.Yaw = Rotation.Yaw - 8192;
                else
                    FireRotation.Yaw = Rotation.Yaw + 8192;
            }
            FireDir = vector(FireRotation);
            FireSpot = ProjStart + FireDist * FireDir;
            HitActor = Trace(HitLocation, HitNormal, FireSpot, ProjStart, false); 
        }
        if ( HitActor != None )
        {
            FireSpot += HitNormal * 2 * RemoteTarget.CollisionHeight;
            if ( !bNovice )
            {
                HitActor = Trace(HitLocation, HitNormal, FireSpot, ProjStart, false);
                if ( HitActor != None )
                    FireSpot += RemoteTarget.CollisionHeight * HitNormal;
            }
            FireDir = Normal(FireSpot - ProjStart);
            FireRotation = rotator(FireDir);        
        }
    }

    if ( warnTarget && (RemoteTarget != None) )
        RemoteTarget.WarnTarget(self, projSpeed, FireDir);

    viewRotation = FireRotation;*/ // FIXME
    return FireRotation;
}








// Let Bot know about incoming projectiles
function WarnTarget(Pawn shooter, float projSpeed, vector FireDir)
{
    local float enemyDist;
    local vector X,Y,Z, enemyDir;

    // AI controlled creatures may duck if not falling
    if ( (Pawn.health <= 0) || (Enemy == None)
        || (Physics == PHYS_Falling) || (Physics == PHYS_Swimming) )
        return;

    /*if ( bNovice )
    {
        if ( FRand() > 0.11 * skill )
            return;
    }*/
    //else if ( FRand() > 0.22 * skill + 0.33 )
    if ( FRand() > 0.22 * skill + 0.33 )
        return;

    // and projectile time is long enough
    enemyDist = VSize(shooter.Location - Location);
    if (enemyDist/projSpeed < 0.11 + 0.15 * FRand())
        return;

    // only if tight FOV
    GetAxes(Rotation,X,Y,Z);
    enemyDir = (shooter.Location - Location)/enemyDist;
    if ((enemyDir Dot X) < 0.8)
        return;

    if (!bSilentGamebot)
        myConnection.SendLine("PRJ" $ib$as$ "Time" $ib$ (enemyDist/projSpeed) $ae$ib$as$"Direction" $ib$ rotator(enemyDir) $ae);
}






function bool TryToDuck(vector duckDir, bool bReversed);





// CloseToPointMan - called if orders are 'follow' to check if close enough to point man
function bool CloseToPointMan(Pawn Other)
{
    //return what engine wants to hear
    return true;
}





//Don't need our bots autotaunting
function MaybeTaunt(Pawn Other);





//Called when someone other than this bot dies.
function Killed(pawn Killer, pawn Other, name damageType)
{
    if ( Killer == self )
        Other.Health = FMin(Other.Health, -11); // don't let other do stagger death

    if ( Pawn.Health <= 0 )
        return;

    if ( OldEnemy == Other )
        OldEnemy = None;

    if ( Enemy == Other )
    {
        Enemy = None;
    }

    if (!bSilentGamebot)
        myConnection.SendLine("KIL" $ib$as$ "Id" $ib$ Other $ae$ib$as$"Killer" $ib$ Killer $ae$ib$as$"DamageType" $ib$ damageType $ae);
}





//Pointless callback
function EnemyAcquired();






//All kinds of shit can call this mostly special trigger points
function Trigger( actor Other, pawn EventInstigator )
{
     //SENDMESSAGE
}






//Much of translocator brains implemented in translocator
//For now better off playing without it - need to research how
//it interacts with path finding
function TranslocateToTarget(Actor Destn)
{
    //MyTranslocator.DesiredTarget = Destn;
}

//Don't let engine pick nodes that must be impact jumped
function bool CanImpactJump()
{
    return false;
}

//Don't handle impact jumps or low gravity manuevers for bots
function ImpactJump();
function BigJump(Actor JumpDest);

//Don't have engine direct to Ambush
function bool FindAmbushSpot()
{
    return false;
}




function PawnDied(Pawn P)
{
    Pawn.UnPossessed();
    Pawn = None;
    Super.PawnDied(P);
    isDR=false;
    //if(!IsInState('Dying'))
    //	BotDeathMatch(Level.Game).SpawnPlayer(self);
    //GotoState('Dying');
    Level.Game.RestartPlayer(self);
}

//Called when bot dies
// function PawnDied() ???
/*function Died(Controller Killer, class<DamageType>damageType, vector HitLocation)
{
    log("BOT DIED!!!!!!!!!!!");

    Pawn.Died(Killer, damageType, HitLocation);

    if (!bSilentGamebot)
        myConnection.SendLine("DIE" $ib$as$ "Killer" $ib$ Killer $ae$ib$as$"DamageType" $ib$ damageType $ae);
}*/

//Called when bot is injured
function NotifyTakeHit(pawn InstigatedBy, vector HitLocation, int Damage, 
    class<DamageType> damageType, vector Momentum)
{
    local float enemyDist;
    local vector enemyDir, X, Y, Z;
    local string messageString;
    
    Super.TakeDamage(Damage, instigatedBy, hitlocation, momentum, damageType);
    
    messageString = "DAM" $ib$as$ "Damage" $ib$ Damage $ae$ib$as$ "DamageType" $ib$ damageType $ae;
    
    // !!! need to fix this and projectile detection to match our
    //periphreal vision parameter.
    // only if tight FOV
    GetAxes(Rotation,X,Y,Z);
    enemyDist = VSize(instigatedBy.Location - Location);
    enemyDir = (instigatedBy.Location - Location)/enemyDist;
    if ((enemyDir Dot X) > 0.8)
        messageString = messageString $ib$as$ "Instigator" $ib$ instigatedBy $ae;   
        
    if (!bSilentGamebot) myConnection.SendLine(messageString);
}

//**********************************************************************************
//Base Monster AI

/*
auto state StartUp
{
    function BeginState()
    {
        SetMovementPhysics(); 
        if (Physics == PHYS_Walking)
            SetPhysics(PHYS_Falling);
    }

Begin:
}
*/

auto state StartUp
{ 
    function BeginState()
    {
        Squad = spawn(DeathMatch(Level.Game).DMSquadClass); // FIXME
        Squad.AddBot(self);
        // Above is a blatant hack because I don't understand why this
        // won't work in AddRemoteBot

        //SetMovementPhysics();
    }

    function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
                        Vector momentum, class<DamageType> damageType)  
    {
        Global.TakeDamage(Damage, instigatedBy, hitlocation, momentum, damageType);
    }

    function Landed(vector HitNormal)
    {
        Global.Landed(HitNormal);
    } 

    function Tick( float DeltaTime ) // jjwang 02/06/11
    {
        local vector cur;
    
        if (botDR==none) return;
        if (Pawn.Health<=0) {isDR=false;return;}
        if (!isDR) {
            if (!botDR.IsRunning()) return;
            else botDR.Stop();
        }
        else {
            if (botDR.IsRunning()) {
                //if (botDR.Step(DeltaTime)) return;
                botDR.SetDT(DeltaTime);
                
                if (botDR.bRFilter) myRotation = botDR.FGetR();
                else {
                    botDR.GetR();
                    myRotation = botDR.current.DR_RP;
                }
                //DesiredRotation = myRotation;
                //Pawn.SetRotation(myRotation);
    
                
                if (botDR.bLFilter) myDestination = botDR.FGetL();
                else {
                    botDR.GetL();
                    myDestination = botDR.current.DR_P;
                }

                cur=Pawn.Location;      
                if (!Pawn.Move(myDestination-Pawn.Location))
                    Pawn.Move(botDR.current.DR_V*DeltaTime);
                // if user doesn't specify rotation, let bot turn to its moving direction. 03/02/06
                //if (botDR.current.DR_RV.pitch==0 && botDR.current.DR_RV.yaw==0 && botDR.current.DR_RV.roll==0)
                //dr=rotator(Normal(Pawn.Location-cur));
                //log("DR TTT:"@Pawn.Rotation.Pitch@Pawn.Rotation.Yaw@Pawn.Rotation.Roll);
                //if (Pawn.Rotation.Yaw==32767||Pawn.Rotation.Yaw==-32767) dr.Pitch=0-dr.Pitch;
                if (botDR.bAutoTurn&&(botDR.current.DR_V.X!=0||botDR.current.DR_V.Y!=0||botDR.current.DR_V.Z!=0))
                    myRotation = rotator(Normal(botDR.current.DR_V));
                    //myRotation = dr;
                Pawn.SetRotation(myRotation);

                //if (!Pawn.SetLocation(myDestination)) {
                    //This is used to keep bot moving after it hit something. To be honest, I don't like this.
                    //Thin is not the correct way to simulte hit responce. Because I must let Tick() as simple
                    //as possible, I let UT to addjust driection after hitted something. So I use: 
                    //	SetLocation(Location + botDR.current.DR_V*DeltaTime);
                    //Anyway, it works.			jjwang 02/06/18
                    //Pawn.SetLocation(Pawn.Location + botDR.current.DR_V*DeltaTime);
                    //Velocity=botDR.current.DR_V;
                    //Pawn.Move(botDR.current.DR_V*DeltaTime);
                    //Pawn.SetRotation(rotator(Normal(botDR.current.DR_V)));
                //}
                
            }
        }
    }
    
    /* This function is used to correct Bot's position and handle hit event.
       What I'm doing is:
          if (hit a fixed wall) {call function HitWall();}
          else {goto move state; let UT deal with hit event;}
       So if Bot hit a mover wall(for example: a door), UT will deal with it.
       I'm not sure, after Bot hit something if DeadReckoning will continue work.
       Right now, I let DeadReckoning continue work.        jjwang 02/06/18
     */
    /*function Timer() // jjwang 02/06/11
    {
        log("TIMER()");
        // Show walking or running
        //if(bIsWalking)
        //  PlayWalking();
        //else
        //  PlayRunning();
 
        if (isDR) {
            log("TIMER");
            if (!botDR.Correct(Level.TimeSeconds)) {
                
                HitActor=Trace(HitLocation,HitNormal,botDR.PreLP(Level.TimeSeconds),Location,true);
                if (bDebug) log("Trace HitActor("$HitActor$") HitLocation("$HitLocation$") HitNormal("$HitNormal$") Destination("$botDR.current.DR_P$")");
                if (HitActor==Level) HitWall(HitNormal,HitActor);
                else if (HitActor != None) {
                    //isDR = false; // I'm not sure weather I should stop dead recknoing. Right now, I let it continue work.
                    myDestination = botDR.PreLP(Level.TimeSeconds+5*deltatime);
                    GotoState('startup','Move');
                }
                
            }
            if (!botDR.bLFilter) start.bLFilter = false; // Used for updating DR replication. 02/06/28
            if (!botDR.bRFilter) start.bRFilter = false; // Used for updating DR replication. 02/06/28
        }
        else SetTimer(0,false);
    }
*/
DRM:
    if (isDR) {
        botDR.Begin();
        SetTimer(deltatime,true);
    }
    //goto 'Begin';
Begin:      
    if (Physics != PHYS_Falling)
    {
        Velocity = vect(0,0,0);
        Acceleration = vect(0,0,0);
        MoveTimer = -1.0;
    }
    //Pawn.PlayWaiting();
    sleep( 30 );
    goto 'Begin';
Test:
    bFire = 0;
    RemoteEnemy=none;
    Enemy=none;
    //PlayDuck();
    sleep( 30 );
    goto 'Test'; 
Move:
    MoveTo(myDestination, , Pawn.bIsWalking);
    if( VSize(Pawn.Location - myDestination) > CollisionRadius )
    {
        goto 'Move';
    }
    goto 'Begin';
Strafe:
    // STRAFE is not working yet. They got rid of the Strafe funcions :-( */
    if(RemoteFocus != none) {
        Focus = RemoteFocus;
    } else if(myFocus != vect(0,0,0)) {
        FocalPoint = myFocus;
    }

    MoveTo(myDestination, , Pawn.bIsWalking);
    
    if( VSize(Location - myDestination) > CollisionRadius )
        goto 'Strafe';
        
    goto 'Begin';
Tracking:       
    if (Physics != PHYS_Falling)
    {
        Velocity = vect(0,0,0);
        Acceleration = vect(0,0,0);
        MoveTimer = -1.0;
    }
    if ( RemoteFocus == none || !FastTrace(RemoteFocus.Location) )
    {
        goto 'Begin';
    }
    else 
    {
        Focus = RemoteFocus;

        Sleep(0.05);
        goto 'Tracking';
    }
Turning:        
    if (Pawn.Physics != PHYS_Falling)
    {
        Velocity = vect(0,0,0);
        Acceleration = vect(0,0,0);
        MoveTimer = -1.0;
    }

    if(myRotationRate != rot(0,0,0)) {
        Pawn.RotationRate = myRotationRate;
    }
    
    if(RemoteFocus != none) {
        Focus = RemoteFocus;
    } else if(myFocus != vect(0,0,0)) {
        FocalPoint = myFocus;
    } else {
        ClientSetRotation(myRotation);
    }

    FinishRotation();

    /* Reset rotation rate to default value */
    if(myRotationRate != rot(0,0,0)) {
        myRotationRate = rot(0,0,0);
        Pawn.RotationRate = Pawn.default.RotationRate;
    }

    Sleep(0.05);
    goto 'Begin'; 
}


state TakeHit
{
    //ignores seeplayer, hearnoise, bump, hitwall;

    function Timer();

Begin:
    error("!!!TakeHit");
    //GotoState(NextState,NextLabel);
}



state FallingState
{
ignores Bump, Hitwall, WarnTarget;

    singular event BaseChange()
    {
        Global.BaseChange();
    }

/*  function AnimEnd(int Channel) // FIXME
    {
        //PlayInAir();
    }

    function ZoneChange(ZoneInfo newZone)
    {
        Global.ZoneChange(newZone);
        if (newZone.bWaterZone) // FIXME
        {
            TweenToWaiting(0.15);
            GotoState('FallingState', 'Splash');
        }
    }*/

    function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
                Vector momentum, class<DamageType> damageType)
    {
        Global.TakeDamage(Damage, instigatedBy, hitlocation, momentum, damageType);
    }
/*
    function bool SetEnemy(Pawn NewEnemy) // FIXME
    {
        Global.SetEnemy(NewEnemy);
    }*/

    function Timer();

    function Landed(vector HitNormal)
    {
        local vector Vel2D;

        if ( MoveTarget != None )
        {
            Vel2D = Velocity;
            Vel2D.Z = 0;
            if ( (Vel2D Dot (MoveTarget.Location - Location)) < 0 )
                Acceleration = vect(0,0,0);
        }
        //Note - physics changes type to PHYS_Walking by default for landed pawns
        Pawn.PlayLanded(Velocity.Z);
        Pawn.TakeFallingDamage();
        if (Velocity.Z < -1.4 * Pawn.JumpZ)
        {
            if ( Pawn.health > 0 )
                GotoState('FallingState', 'Landed');
        }
        else 
            GotoState('FallingState', 'Done');
    }

    function SeePlayer(Pawn SeenPlayer)
    {
        Global.SeePlayer(SeenPlayer);
    }

    function EnemyNotVisible()
    {
        Global.EnemyNotVisible();
    }


    function SetFall()
    {
        if (!Pawn.bUpAndOut)
            GotoState('FallingState');
    }

    function EnemyAcquired()
    {
        Global.EnemyAcquired();
    }

    function BeginState();

    function EndState()
    {
        //log(self$" left falling state ");
        Pawn.bUpAndOut = false;
        //Pawn.bJumpOffPawn = false;
        //bBigJump = false;
        /*if ( bImpactJumping )
        {
            bImpactJumping = false;
            SwitchToBestWeapon();
        }*/ // FIXME
    }

FireWhileFalling:
    if ( Physics != PHYS_Falling )
        Goto('Done');
    else
        Sleep(0.5 + 0.2 * FRand());
    if ( LineOfSightTo(Enemy) )
        Goto('FireWhileFalling');

LongFall:
    if ( Pawn.bCanFly )
    {
        SetPhysics(PHYS_Flying);
        Goto('Done');
    }
    Sleep(0.7);
    /*if ( (Velocity.Z > -150) && (Region.Zone.ZoneGravity.Z <= Region.Zone.Default.ZoneGravity.Z) ) //stuck
    {
        SetPhysics(PHYS_Falling);

        Velocity = groundspeed * VRand();

        Velocity.Z = FMax(JumpZ, 250);
    }*/ // FIXME
    Goto('LongFall');

Landed:
    //log("Playing"@animsequence@"at"@animframe);
    Disable('AnimEnd');
    FinishAnim();
    //log("Finished"@animsequence@"at"@animframe);
Done:
    //log("After fall"@NextState@NextLabel);
    /*if ( Pawn.NextAnim == '' )
    {
        bUpAndOut = false;
        if ( (NextState != '') && (NextState != 'FallingState') )
            GotoState(NextState, NextLabel);
        else 
        {
            log("Going from -Done");
            GotoState('StartUp');
        }
    }
    if ( !bUpAndOut )
    {
        if ( NextAnim == 'Fighter' )
            TweenToFighter(0.2);
        else
            TweenAnim(NextAnim, 0.12);
    } */ // FIXME

Splash:
    Pawn.bUpAndOut = false;
    /*if ( NextState != '' )
        GotoState(NextState, NextLabel);
    else
    {
        log("Going from -Splash");
        GotoState('StartUp');
    }*/ // FIXME
            
Begin:
    if ( !Pawn.bUpAndOut ) // not water jump
    {
        /*if ( Region.Zone.bWaterZone )
        {
            SetPhysics(PHYS_Swimming);
            GotoState(NextState, NextLabel);
        }*/ // FIXME

PlayFall:
        /*if ( (Velocity.Z > 300) && (MoveTarget != None)
            && ((FRand() < 0.13) || ((Region.Zone.ZoneGravity.Z > Region.Zone.Default.ZoneGravity.Z) && (FRand() < 0.2)))
            && (VSize(Destination - Location) > 160)
            && ((Vector(Rotation) Dot (Destination - Location)) > 0) )
            PlayFlip();
        else 
            TweenToFalling();*/ // FIXME
    }
    if (Physics != PHYS_Falling)
        Goto('Done');

    /*if ( bJumpOffPawn )
    {
        if ( bBigJump )
        {
            While( bBigJump )
            {
                Sleep(0.25);
                Acceleration = AccelRate * Normal(Destination - Location);
            }
        }
        else
        {
            Sleep(0.2);
            While ( (Abs(Velocity.X) < 60) && (Abs(Velocity.Y) < 60) )
                Sleep(0.1);
            Acceleration = vect(0,0,0);
            Sleep(1.5);
        }
        bBigJump = false;
        bJumpOffPawn = false;
    }
    else */ // FIXME
        Sleep(2);

    Goto('LongFall');

Ducking:
    /*if ( Region.Zone.ZoneGravity.Z > Region.Zone.Default.ZoneGravity.Z )
    {
        Acceleration = AccelRate * Normal(Destination - Location);
        if ( bNovice )
            Sleep(0.4);
        PlayInAir();
    } */ // FIXME
}


//called from pressure zone just get the hell back out
state VictoryDance
{
    function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
            Vector momentum, class<DamageType> damageType)
    {
        Global.TakeDamage(Damage, instigatedBy, hitlocation, momentum, damageType);
    }

    function EnemyAcquired()
    {
        Global.EnemyAcquired();
    }

    function BeginState();

Begin:
    //GotoState(NextState,NextLabel);
}


state GameEnded
{
//ignores SeePlayer, EnemyNotVisible, HearNoise, TakeDamage, Died, Bump, Trigger, HitWall, HeadZoneChange, FootZoneChange, ZoneChange, Falling, WarnTarget, PainTimer;
ignores SeePlayer, EnemyNotVisible, HearNoise, TakeDamage, Bump, Trigger, HitWall, ZoneChange, Falling, WarnTarget, PainTimer;

    function SpecialFire()
    {
    }
    function bool TryToDuck(vector duckDir, bool bReversed)
    {
        return false;
    }
    function SetFall()
    {
    }
    function LongFall()
    {
    }
    function Killed(pawn Killer, pawn Other, name damageType)
    {
    }
    function ClientDying(class<DamageType> DamageType, vector HitLocation)
    {
    }

    function BeginState()
    {
        Pawn.SimAnim.AnimRate = 0.0;
        bFire = 0;
        bAltFire = 0;
        //SimAnim.Y = 0;
        SetCollision(false,false,false);
        SetPhysics(PHYS_None);
        Velocity = vect(0,0,0);
        if (!bSilentGamebot) myConnection.SendLine("FIN");
    }
}


state Dying
{
//ignores SeePlayer, EnemyNotVisible, HearNoise, Died, Bump, Trigger, HitWall, HeadZoneChange, FootZoneChange, ZoneChange, Falling, WarnTarget, LongFall, SetFall, PainTimer;
//ignores SeePlayer, EnemyNotVisible, HearNoise, Died, Bump, Trigger, HitWall, ZoneChange, Falling, WarnTarget, LongFall, SetFall, PainTimer;
ignores Trigger, Bump, HitWall, HeadVolumeChange, PhysicsVolumeChange, Falling;
    function ReStartPlayer()
    {
        log("DYING, RESTARTPLAYER");
        Velocity = vect(0,0,0);
        Acceleration = vect(0,0,0);
        //ViewRotation = Rotation;
        //SetRotation(Rotation);
        ReSetSkill();
        SetPhysics(PHYS_Falling);
        //SetOrders(BotReplicationInfo(PlayerReplicationInfo).RealOrders, BotReplicationInfo(PlayerReplicationInfo).RealOrderGiver, true); // FIXME
        //GotoState('StartUp');

        //ServerReStartPlayer();
        //Level.Game.ReStartPlayer(self);
        // FIXME
        //BotDeathMatch(Level.Game).SpawnPlayer(self);

        if ( !IsInState('GameEnded') )
        {
            //log("not game ended, restart player");
            GotoState('Dying', 'TryAgain');
        }
    }

    function BeginState()
    {
        Enemy = None;
        //PointDied = -1000; // FIXME
        bFire = 0;
        bAltFire = 0;
        bInitLifeMessage = false;
        //MyTranslocator = None; // FIXME
        //log("DYING, BEGINSTATE");
    }


Begin:
    if ( Level.Game.bGameEnded )
        GotoState('GameEnded');
    Sleep(0.2);
    //log("DYING, BEGIN");
TryAgain:
    //if ( !bHidden )
    //{
    //	HidePlayer();
    //} // FIXME
    Sleep(0.25 + DeathMatch(Level.Game).SpawnWait(self));
    log("DYING, TRYAGAIN");
    if(Pawn == None) {
        log("DYING, TRYAGAIN, Pawn == None");
        ReStartPlayer();
        Goto('TryAgain');
    } else {
        log("DYING, TRYAGAIN, Pawn != None");
        GotoState('StartUp');
    }
WaitingForStart:
    //bHidden = true;
    //bHidden = false;
    log("DYING, WAITINGFORSTART");
    Goto('Begin');
}

state Dead
{
ignores SeePlayer, HearNoise, KilledBy;

function BeginState()
{
    log("Dead, BeginState");
    //ServerReStartPlayer();
}
}

//-------------RemoteBot Specific Functions--------------------


//Check to see if a location is really in front of the bot 
//may be a more efficient algorithm
function bool inFront(Vector A)
{
    local rotator angle;
    
    //can't be infront if inside bot
    if( VSize(Location - A) < CollisionRadius )
        return false;

    angle = ( Rotation - rotator(A - Location) );

    if( (cos(angle.Yaw / 10435.0) < remoteVisionLimit) ||
        (cos(angle.Pitch / 10435.0) < remoteVisionLimit) )
        return false;
    else
        return true;
}


//Called by the gametype when someone else is injured by the bot
function HurtOther(int Damage, name DamageType, pawn injured)
{
    if (!bSilentGamebot)
        myConnection.SendLine("HIT" $ib$as$ "Id" $ib$ injured $ae$ib$as$"Damage" $ib$ Damage $ae$ib$as$ 
        "DamageType" $ib$ DamageType $ae);
}

function checkSelf()
{   
    local int ArmorAmount,i;
    local string outstring;

    ArmorAmount = 0;
    i = 0;

    outstring = "SLF" $ib$as$ "Id" $ib$ self $ae$ib$as$ 
        "Rotation" $ib$ Pawn.Rotation $ae$ib$as$
        "Location" $ib$ Pawn.Location $ae$ib$as$ 
        "Velocity" $ib$ Pawn.Velocity $ae$ib$as$ 
        "Name" $ib$ PlayerReplicationInfo.PlayerName $ae$ib$as$ 
        //	"Team" $ib$ PlayerReplicationInfo.Team $ae$ib$as$ 
        // Team works, but break the Java bot
        "Health" $ib$ Pawn.Health $ae$ib$as$
        "Weapon" $ib$ Pawn.Weapon $ae;

    if(Pawn.Weapon != None) {
        outstring = outstring $ib$as$ "CurrentAmmo" $ib$ Pawn.Weapon.AmmoAmount(0) $ae;  //FIXME
    }
    //	"Armor" $ib$ ArmorAmount $ae;
    //        ae;
    
    if( bFire != 0 )
        outstring = outstring $ib$as$ "Firing" $ib$ "1" $ae;
    else if( bAltFire != 0 )
        outstring = outstring $ib$as$ "AltFiring" $ib$ "2" $ae;
    else 
        outstring = outstring $ib$as$ "AltFiring" $ib$ "0" $ae;

    if (!bSilentGamebot) myConnection.sendLine(outstring);
}

function checkVision()
{
    local Inventory I;
    local Mover M;
    local Controller P;
    local CTFFlag C;
    local NavigationPoint N;
    local vector HitL, HitN;
    //local int temp;
    local string outstring;
    
    //!!! view rotation sometimes falls out of synch with rotation? wtf??
    
    for ( P=Level.ControllerList; P!=None; P=P.NextController )
    {
        if( (P != self) && !P.bHidden  && FastTrace(P.Location) && inFront(P.Location) &&
            ( Trace(HitL, HitN, P.Location) == P) )
        {
            outstring = "PLR" $ib$as$ "Id" $ib$ P $ae$ib$as$ 
                "Rotation" $ib$ P.Rotation $ae$ib$as$ 
                "Location" $ib$ P.Location $ae$ib$as$ 
                "Velocity" $ib$ P.Velocity $ae$ib$as$ 
                "Name" $ib$ PlayerReplicationInfo.PlayerName $ae$ib$as$
                    "Team" $ib$ 0 $ae$ib$as$
              //				"Team" $ib$ P.PlayerReplicationInfo.Team $ae$ib$as$ 
                "Reachable" $ib$ actorReachable(P) $ae$ib$as$ 
                "Weapon" $ib$ P.Pawn.Weapon.Class $ae;
                
            if( P.bFire != 0 )
                outstring = outstring $ib$as$ "Firing" $ib$ "1" $ae;
            else if( P.bAltFire != 0 )
                outstring = outstring $ib$as$ "AltFiring" $ib$ "2" $ae;
            else 
                outstring = outstring $ib$as$ "AltFiring" $ib$ "0" $ae;
                
            if (!bSilentGamebot) myConnection.sendLine(outstring);
        }
    }
    
    foreach VisibleCollidingActors(class'Inventory',I,Pawn.SightRadius)
    {
        if( I.GetStateName() == 'Pickup'&& !I.bHidden && inFront(I.Location) &&
            ( Trace(HitL, HitN, I.Location) == none) && !bSilentGamebot)
        {
            myConnection.SendLine("INV" $ib$as$ "Id" $ib$ I $ae$ib$as$ 
                "Location" $ib$ I.Location $ae$ib$as$ 
                "Reachable" $ib$ actorReachable(I) $ae$ib$as$
                "Class" $ib$ I.Class $ae);
        }
    }
    
    foreach VisibleCollidingActors(class'Mover',M,Pawn.SightRadius)
    {
        if( !M.bHidden && inFront(M.Location) && !bSilentGamebot &&
            ( Trace(HitL, HitN, M.Location) == none) )
        {
            myConnection.SendLine("MOV" $ib$as$ "Id" $ib$ M $ae$ib$as$ 
                "Location" $ib$ M.Location $ae$ib$as$ 
                "Reachable" $ib$ actorReachable(M) $ae$ib$as$
                "DamageTrig" $ib$ M.bDamageTriggered $ae$ib$as$
                "Class" $ib$ M.Class $ae);
        }
    }

    for ( N=Level.NavigationPointList; N!=None; N=N.NextNavigationPoint )
    {
        //try letting them see inv navpoints - may be needed for some levels
        //if( !N.IsA('InventorySpot') && FastTrace(N.Location) && inFront(N.Location))
        if( FastTrace(N.Location) && inFront(N.Location) &&
            ( Trace(HitL, HitN, N.Location) == none) )
        {
            /*if(N.IsA('ControlPoint'))  // FIXME 
            {
                if( ControlPoint(N).ControllingTeam == none )
                    temp = 255;
                else
                    temp = ControlPoint(N).ControllingTeam.TeamIndex;
                
                if (!bSilentGamebot)
                    myConnection.SendLine("DOM" $ib$as$ "Id" $ib$ N $ae$ib$as$"Location"$ib$ N.Location $ae$ib$as$ 
                                          "Reachable" $ib$ actorReachable(N) $ae$ib$as$"Controller" $ib$ temp $ae);
            }
            else */
                if (!bSilentGamebot)
                    myConnection.SendLine("NAV" $ib$as$ "Id" $ib$ N $ae$ib$as$"Location" $ib$ N.Location $ae$ib$as$ 
                                          "Reachable" $ib$ actorReachable(N) $ae);
        }
    }
    
    if (myConnection.Parent.gameClass == "BotCTF")
    {
        foreach AllActors (class'CTFFlag', C)
        {
            //not using trace because players tend to obstruct flags wildly
            if( FastTrace(C.Location) && inFront(C.Location) && C.Holder != self )
            {
                outstring = "FLG" $ib$as$ "Id" $ib$ C $ae;
                //when a flag is held its location is not updated by engine =(
                if( C.GetStateName() == 'Held') 
                    outstring = outstring $ib$as$ "Location" $ib$ C.Holder.Location $ae$ib$as$ 
                                "Holder" $ib$ C.Holder $ae;
                else
                    outstring = outstring $ib$as$ "Location" $ib$ C.Location $ae;
                    
                outstring = outstring $ib$as$ "Team" $ib$ C.Team $ae$ib$as$
                        "Reachable" $ib$ actorReachable(C) $ae$ib$as$ 
                        "State" $ib$ C.GetStateName() $ae;
                if (!bSilentGamebot) myConnection.SendLine(outstring);
            }
        }
    }
}

//Shortten up the MakeItem calls
function string MakeItem(string first, string second)
{
    return myConnection.MakeItem(first,second); 
}

function Destroyed()
{
    if(Pawn != None) {
    Pawn.Destroy();
    }
    Super.Destroyed();
}

function ChangeWeapon()
{

}

function ServerChangedWeapon(Weapon OldWeapon, Weapon NewWeapon)
{

}

state MoveToGoal
{
    function BeginState();
}

//-----------------

defaultproperties
{
     bDebug=True
     remoteVisionLimit=0.707000
     DeltaTime=0.100000
}