USARBot.ViewBot

//=============================================================================
// ViewBot.
// Based on Bot class
// (RemoteBot without net connections)
// by Marco Zaratti - marco.zaratti@gmail.com
//=============================================================================
class ViewBot extends Bot;


var bool bDebug;

//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 float remoteVisionLimit;

//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 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()
{
    botDR.SetT(Level.TimeSeconds);// Added by jjwang. When the bot changes its base, refreshs the DR. 02/28/03
    Super(Pawn).BaseChange();
}

//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');
    }

    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);

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

    OldMessageID = MessageID;
    OldMessageType = MessageType;

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

function SendGlobalMessage(PlayerReplicationInfo Recipient, name MessageType, byte MessageID, float Wait)
{
    if ( (MessageType == OldMessageType) && (MessageID == OldMessageID)
        && (Level.TimeSeconds - OldMessageTime < Wait) )
        return;

    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 )
{
}
event TeamMessage( PlayerReplicationInfo PRI, coerce string S, name Type, optional bool bBeep )
{
}

//events for recieving tokenized voice message
function BotVoiceMessage(name messagetype, byte MessageID, Controller Sender)
{
}

//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);

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

//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;
    }
}

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

event Touch( Actor Other )
{
}

//called on hitting a wall
event bool NotifyHitWall(vector HitNormal, actor HitActor)
{
    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);
        }
    }

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

function SetFall()
{
}

function LongFall()
{
}

//called when someone picksup a nearby object WORKING????
function HearPickup(Pawn Other)
{
}

//called when sound is made
function HearNoise(float Loudness, Actor NoiseMaker)
{
}

//called periodicaly for each player in view
function SeePlayer(Pawn SeenPlayer)
{
}

// 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 ( RemoteTarget == None || !FastTrace(RemoteTarget.Location) || !inFront(RemoteTarget.Location) )
        return vector(Pawn.Rotation);
    FireSpot = RemoteTarget.Location;
    TargetDist = VSize(RemoteTarget.Location - ProjStart);
}

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;
    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;
}

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;
    }
}

//Pointless callback
function EnemyAcquired();

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

//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)
{
}

//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;
    Level.Game.RestartPlayer(self);
}

//Called when bot is injured
function NotifyTakeHit(pawn InstigatedBy, vector HitLocation, int Damage,
    class<DamageType> damageType, vector Momentum)
{
    Super.TakeDamage(Damage, instigatedBy, hitlocation, momentum, damageType);
}

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

auto state StartUp
{
    function BeginState()
    {
        Squad = spawn(DeathMatch(Level.Game).DMSquadClass); // FIXME
        Squad.AddBot(self);
    }

    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;
                }

                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 (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));
                Pawn.SetRotation(myRotation);
            }
        }
    }

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
{
    function Timer();

Begin:
    error("!!!TakeHit");
}

state FallingState
{
ignores Bump, Hitwall, WarnTarget;

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

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

    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()
    {
        Pawn.bUpAndOut = false;
    }

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);
    Goto('LongFall');

Landed:
    Disable('AnimEnd');
    FinishAnim();
Done:

Splash:
    Pawn.bUpAndOut = false;

Begin:
    if ( !Pawn.bUpAndOut ) // not water jump
    {

PlayFall:
    }
    if (Physics != PHYS_Falling)
        Goto('Done');

        Sleep(2);

    Goto('LongFall');

Ducking:
}

//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);
    }
}

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);
        ReSetSkill();
        SetPhysics(PHYS_Falling);

        if ( !IsInState('GameEnded') )
        {
            GotoState('Dying', 'TryAgain');
        }
    }

    function BeginState()
    {
        Enemy = None;
        bFire = 0;
        bAltFire = 0;
        bInitLifeMessage = false;
    }

Begin:
    if ( Level.Game.bGameEnded )
        GotoState('GameEnded');
    Sleep(0.2);
TryAgain:
    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:
    log("DYING, WAITINGFORSTART");
    Goto('Begin');
}

state Dead
{
ignores SeePlayer, HearNoise, KilledBy;

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

//-------------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 int HurtOther(int Damage, name DamageType, pawn injured)
{
    return 0;
}

function checkSelf()
{
}

function checkVision()
{
}

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

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

function ChangeWeapon()
{

}

function ServerChangedWeapon(Weapon OldWeapon, Weapon NewWeapon)
{

}

state MoveToGoal
{
    function BeginState();
}

function ExecuteWhatToDoNext();

function bool NeedWeapon();

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

defaultproperties
{
     bDebug=False
     bHidden=True
     DrawScale=0.0
     remoteVisionLimit=0.707000
    DeltaTime=0.100000
}