XGame.xPlayer

class xPlayer extends UnrealPlayer
    DependsOn(xUtil);

#exec OBJ LOAD File="MenuSounds.uax"

// attract mode
var AttractCamera camlist[20];
var int numcams, curcam;
var Pawn attracttarget, attracttarget2;
var float camtime, targettime, gibwatchtime;
var Vector focuspoint;

// combos
const MinComboKeyTime = 0.05;   // keys pressed faster than this will be considered a double-press
const MaxComboKeyTime = 0.35;   // max time player has between button presses

var transient int InputHistory[4];
var transient float LastKeyTime;
var transient int OldKey;
var float MinAdrenalineCost;
var string ComboNameList[16];
var class<Combo> ComboList[16];

var xUtil.PlayerRecord PawnSetupRecord;
var float LastRulesRequestTime;
var float LastMapListRequestTime;

var bool autozoom;
var globalconfig bool bClassicTrans;
var bool bHighBeaconTrajectory;
var bool bWaitingForPRI, bWaitingForVRI;
var config bool bDebuggingVoiceChat;

var config bool bAutoDemoRec;

delegate ProcessRule(string NewRule);   // Should be assigned elsewhere
delegate ProcessMapName(string NewMap);

replication
{
    // client to server
    reliable if ( Role < ROLE_Authority )
        ServerDoCombo, ServerRequestRules, ServerRequestMapList, AdminMenu, ServerRequestPlayerInfo,
        ServerSpecViewGoal, ServerSetClassicTrans;
    unreliable if( Role < ROLE_Authority )
        L33tPhrase;
    reliable if ( Role == ROLE_Authority)
        ClientReceiveRule, ClientReceiveMapName, ClientReceiveCombo, ClientReceiveBan;
}

exec function CheckPriority()
{
    local Inventory Inv;
    local int Count;

    if ( Pawn == None )
    {
        DebugMessage("Pawn is none - returning");
        return;
    }

    for( Inv = Pawn.Inventory; Inv != None && Count < 1000; Inv = Inv.Inventory )
    {
        if ( Weapon(Inv) != None )
            DebugMessage("Weapon:"$Inv.Name@"Priority:"$Weapon(Inv).Priority,'PriorityDebug');

        Count++;
    }
}

simulated function DebugMessage(string DebugString, optional name Type)
{
    ClientMessage(DebugString);
    log(DebugString,Type);
}


simulated function String GetRoleString()
{
    local String T;

    T = "Role: ";
    Switch(Role)
    {
        case ROLE_None: T=T$"None"; break;
        case ROLE_DumbProxy: T=T$"DumbProxy"; break;
        case ROLE_SimulatedProxy: T=T$"SimulatedProxy"; break;
        case ROLE_AutonomousProxy: T=T$"AutonomousProxy"; break;
        case ROLE_Authority: T=T$"Authority"; break;
    }

    return T;
}

simulated function String GetPhysicsString()
{
    Local String T;

    T = "Physics: ";
    Switch( Pawn.Physics )
    {
        case PHYS_None: T=T$"None"; break;
        case PHYS_Walking: T=T$"Walking"; break;
        case PHYS_Falling: T=T$"Falling"; break;
        case PHYS_Swimming: T=T$"Swimming"; break;
        case PHYS_Flying: T=T$"Flying"; break;
        case PHYS_Rotating: T=T$"Rotating"; break;
        case PHYS_Projectile: T=T$"Projectile"; break;
        case PHYS_Interpolating: T=T$"Interpolating"; break;
        case PHYS_MovingBrush: T=T$"MovingBrush"; break;
        case PHYS_Spider: T=T$"Spider"; break;
        case PHYS_Trailer: T=T$"Trailer"; break;
        case PHYS_Ladder: T=T$"Ladder"; break;
        case PHYS_Karma: T=T$"Karma"; break;
    }
    return T;
}

// Voice chat debug

function ServerRequestRules()
{
    local GameInfo.ServerResponseLine Response;
    local int i;


    if ( Level.Pauser == None && Level.TimeSeconds - LastRulesRequestTime < 3.0)
    {
        log("ServerRequestRules Level.TimeSeconds:"$Level.TimeSeconds@"LastRequestTime:"$LastRulesRequestTime);
        return;
    }

    LastRulesRequestTime = Level.TimeSeconds;
    Level.Game.GetServerDetails(Response);
    ClientReceiveRule("");
    for (i=0;i<Response.ServerInfo.Length;i++)
        ClientReceiveRule(Response.ServerInfo[i].Key$"="$Response.ServerInfo[i].Value);
}

function ClientReceiveRule(string NewRule)
{
    ProcessRule(NewRule);
}

function ServerRequestMapList()
{
    local int x;
    local array<string> MapList;

    if ( Level.Pauser == None &&
        (Level.TimeSeconds - LastMapListRequestTime < 3.0 || Level.Game.MapListType == "") )
        return;

    LastMapListRequestTime = Level.TimeSeconds;
    MapList = Level.Game.GetMapRotation();

    ClientReceiveMapName("");
    for (x = 0; x < MapList.length; x++)
        ClientReceiveMapName(MapList[x]);
}

function ClientReceiveMapName(string NewMap)
{
    ProcessMapName(NewMap);
}

function StopFiring()
{
}

simulated function PlayBeepSound()
{
    if ( ViewTarget != None )
        ViewTarget.PlaySound(sound'MenuSounds.selectJ', SLOT_None,,,,,false);
}

simulated function float RateWeapon(Weapon w)
{
    return w.Default.Priority;
}

exec function L33TPhrase( int phraseNum )
{
    SendMessage(None, 'HIDDEN', phraseNum, 5, 'GLOBAL');
}

simulated event PostBeginPlay()
{
    local int c;

    Super.PostBeginPlay();

    for (c = 0; c < ArrayCount(ComboList); c++)
    {
        if ( ComboNameList[c] != "" )
        {
            ComboList[c] = class<Combo>(DynamicLoadObject(ComboNameList[c],class'Class'));
            if ( ComboList[c] == None )
                break;
            MinAdrenalineCost = FMin(MinAdrenalineCost,ComboList[c].Default.AdrenalineCost);
        }
    }
    FillCameraList();
    LastKillTime = -5.0;
}

simulated event PostNetBeginPlay()
{
    super.PostNetBeginPlay();
    if ( Level.NetMode != NM_DedicatedServer )
        ServerSetClassicTrans(bClassicTrans);
}

function ServerSetClassicTrans(bool B)
{
    bHighBeaconTrajectory = B;
}

simulated function ClientReceiveCombo(string NewCombo)
{
    local int i;

    for ( i=0; i<16; i++ )
    {
        if ( ComboNameList[i] ~= NewCombo )
            return;
        else if ( ComboNameList[i] == "" )
        {
            ComboNameList[i] = NewCombo;
            ComboList[i] = class<Combo>(DynamicLoadObject(ComboNameList[i],class'Class'));
            if ( ComboList[i] == None )
                return;
            MinAdrenalineCost = FMin(MinAdrenalineCost,ComboList[i].Default.AdrenalineCost);
            return;
        }
    }
}

event PlayerTick( float DeltaTime )
{
    local int CurrentKey, DiffKey;
    local int c, i;
    local bool bFullBuffer,bMatch;

    Super.PlayerTick(DeltaTime);

    if ( Viewport(Player) == None )
        return;

    if ( (Pawn == None) || !bAdrenalineEnabled || (Adrenaline < MinAdrenalineCost) )
    {
        InputHistory[0] = 0;
        return;
    }
    CurrentKey = 0;

    if (aForward > 0)       CurrentKey = CurrentKey | 1; // CK_Up
    else if (aForward < 0)  CurrentKey = CurrentKey | 2; // CK_Down
    if (aStrafe > 0)        CurrentKey = CurrentKey | 4; // CK_Left
    else if (aStrafe < 0)   CurrentKey = CurrentKey | 8; // CK_Right

    if ( CurrentKey != OldKey )
    {
        DiffKey = CurrentKey & ~OldKey; // keys that are pressed now but were not last frame

        if (DiffKey != 0)
        {
            if (Level.TimeSeconds - LastKeyTime < MinComboKeyTime) // if the time was too short between the last keypress, consider it a double press
            {
                InputHistory[0] = InputHistory[0] | DiffKey;
            }
            else if (Level.TimeSeconds - LastKeyTime > MaxComboKeyTime) // wipe the buffer if too long since last keypress
            {
                InputHistory[0] = Diffkey;
                InputHistory[1] = 0;
                LastKeyTime = Level.TimeSeconds;
            }
            else
            {
                bFullBuffer = true;
                for ( i=3; i>0; i-- )
                {
                    InputHistory[i] = InputHistory[i - 1];
                    if ( InputHistory[i] == 0 )
                        bFullBuffer = false;
                }
                InputHistory[0] = DiffKey;
                LastKeyTime = Level.TimeSeconds;
            }

            // check for combo matches
            if ( bFullBuffer )
            {
                for ( c=0; c<16; c++ )
                {
                    if ( ComboList[c] == None )
                        break;
                    else if ( (ComboList[c].Default.species == None) || (ComboList[c].Default.species == xPawn(Pawn).Species) )
                    {
                        bMatch = true;
                        for ( i=0; i <4; i++)
                            if ( InputHistory[i] != ComboList[c].Default.keys[i] )
                            {
                                bMatch = false;
                                break;
                            }

                        if ( bMatch )
                        {
                            DoCombo(ComboList[c]);
                            InputHistory[0] = 0;
                        }
                    }
                }
            }
        }

        OldKey = CurrentKey;
    }
}

function DoCombo( class<Combo> ComboClass )
{
    if (Adrenaline >= ComboClass.default.AdrenalineCost && !Pawn.InCurrentCombo() )
    {
        ServerDoCombo( ComboClass );
    }
}

function ServerDoCombo( class<Combo> ComboClass )
{
    if ( (ComboClass == None) || (xPawn(Pawn) == None) )
        return;
    if (Adrenaline >= ComboClass.default.AdrenalineCost && !Pawn.InCurrentCombo() )
    {
        if (ComboClass.default.ExecMessage != "")
            ReceiveLocalizedMessage( class'ComboMessage', , , , ComboClass );

        xPawn(Pawn).DoCombo( ComboClass );
    }
}

state AttractMode
{
    ignores SwitchWeapon, RestartLevel, ClientRestart, Suicide,
     ThrowWeapon, NotifyPhysicsVolumeChange, NotifyHeadVolumeChange,
     Say, TeamSay;

    function bool IsSpectating()
    {
        return true;
    }

    function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
    {
    }

    function PlayerMove(float DeltaTime)
    {
        local float deltayaw, destyaw;
        local Rotator newrot;

        if ( attracttarget == None )
            return;

        // updates camera yaw to smoothly rotate to the pawn facing
        if ( bBehindView )
        {
            if ( (attracttarget.Controller == None) || (AttractTarget.Controller.Enemy == None) )
                return;
            NewRot = Rotator(attracttarget.controller.Enemy.location - attracttarget.location);
            destyaw = NewRot.Yaw;
            deltayaw = (destyaw & 65535) - (rotation.yaw & 65535);
            if (deltayaw < -32768) deltayaw += 65536;
            else if (deltayaw > 32768) deltayaw -= 65536;

            newrot = rotation;
            newrot.yaw += deltayaw * DeltaTime;
            SetRotation(newrot);
        }
        else
        {
            newrot = CameraTrack(attracttarget, DeltaTime);
            SetRotation(newrot);
        }
    }

    exec function NextWeapon()
    {
    }

    exec function PrevWeapon()
    {
    }

    exec function Fire( optional float F )
    {
        // start playing
    }

    exec function AltFire( optional float F )
    {
        Fire(F);
    }

    function BeginState()
    {
        if ( Pawn != None )
        {
            SetLocation(Pawn.Location);
        }
        bCollideWorld = true;
        if ( curcam == -1 )
        {
            FillCameraList();
            camtime = 0;
            targettime = 0;
            autozoom = true;
            curcam = -1;
        }

        Timer();
        SetTimer(0.5, true);
    }

    function EndState()
    {
        PlayerReplicationInfo.bIsSpectator = false;
        bCollideWorld = false;
        curcam = -1;
    }

    function Timer()
    {
        local bool switchedbots;
        local Vector newloc;
        local int newcam;

        camtime += 0.5;
        targettime += 0.5;
        bFrozen = false;

        // keep watching a target for a few seconds after it dies
        if (gibwatchtime > 0)
        {
            gibwatchtime -= 0.5;
            if (gibwatchtime <= 0)
                attracttarget = None;
            else
                return;
        }
        else if ( attracttarget != None && attracttarget.Health <= 0 )
        {
            gibwatchtime = 4;
            //Log("attract: watching gib");
        }

        // switch targets //
        if (attracttarget == None
            || targettime > 30 )
        {
            attracttarget = PickNextBot(attracttarget);
            switchedbots = true;
            targettime = 0;
         }

        if (attracttarget == None)
            return;

        // switch views //
        if (
            switchedbots ||
            camtime > 10 ||
            bBehindView == false && (rotation.pitch < -10000 || !LineOfSight(curcam, attracttarget))
        )
        {
            camtime = 0;
            FovAngle = default.FovAngle;
            SetViewTarget(self);
            bBehindView = false;

            // look for a placed camera
            if (FindFixedCam(attracttarget, newcam))
            {
                focuspoint = attracttarget.Location;
                curcam = newcam;
                SetLocation(camlist[curcam].Location);
                FovAngle = camlist[curcam].ViewAngle;

                SetRotation(CameraTrack(attracttarget, 0));
                //Log("attract: camera "$camlist[curcam]);
            }
            // use a floating camera
            else if (FRand() < 0.5)
            {
                newloc = FindFloatingCam(attracttarget);
                focuspoint = attracttarget.Location;
                curcam = -1;
                SetLocation(newloc);

                SetRotation(CameraTrack(attracttarget, 0));
                //Log("attract: free camera");
            }
            // chase mode
            else
            {
                curcam = -1;
                SetViewTarget(attracttarget);
                bBehindView = true;
                SetRotation(attracttarget.rotation);
                CameraDeltaRotation.Pitch = -3000;
                CameraDist = 6;
                //Log("attract: chase camera");
            }
        }
    }
}

state ViewPlayer extends PlayerWalking
{
    function PlayerMove(float DeltaTime)
    {
        Super.PlayerMove(DeltaTime);

        CameraSwivel = CameraTrack(pawn, DeltaTime);
    }

    function PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation )
    {
        // not calling super
        CameraRotation = CameraSwivel;
        CameraLocation = location; //camlist[curcam].location;
        ViewActor = self;
    }

    function BeginState()
    {
        FillCameraList();
        bBehindView = true;
        SetViewTarget(self);
        curcam = -2;
        autozoom = true;
        Timer();
        SetTimer(0.5, true);
    }

    function EndState()
    {
        CameraSwivel = rot(0,0,0);
        bBehindView = false;
        FovAngle = default.FovAngle;
        DesiredFOV = FovAngle;
        SetViewTarget(pawn);
    }

    function Timer()
    {
        local Vector newloc;
        local int newcam;

        if (curcam == -2 || !LineOfSight(curcam, pawn))
        {
            //Log("attract: switch camera");

            camtime = 0;

            if (FindFixedCam(pawn, newcam))
            {
                if (curcam != newcam)
                {
                    focuspoint = pawn.Location;
                    curcam = newcam;
                    SetLocation(camlist[curcam].location);
                    FovAngle = camlist[curcam].ViewAngle;
                    //Log("attract: viewing from "$camlist[curcam]);
                }
                else
                {
                    //Log("attract: zoinks! this shouldn't happen");
                }
            }
            else
            {
                newloc = FindFloatingCam(pawn);
                SetLocation(newloc);
                curcam = -1;
                FovAngle = default.FovAngle;
                focuspoint = pawn.Location;
                //Log("attract: floating");
            }

            CameraSwivel = CameraTrack(pawn, 0);
        }
    }

    exec function TogglePlayerAttract()
    {
        GotoState('PlayerWalking');
    }
}

function FillCameraList()
{
    local AttractCamera cam;
    numcams = 0;
    foreach AllActors(class'AttractCamera', cam)
    {
        camlist[numcams++] = cam;
        if (numcams == 20) break;
    }
}

function bool FindFixedCam(Pawn target, out int newcam)
{
    local int c, bestc;
    local float dist, bestdist;

    bestc = -1;

    for (c = 0; c < numcams; c++)
    {
        dist = VSize(target.location - camlist[c].location);

        if ((bestc == -1 || dist < bestdist) && LineOfSight(c, target))
        {
            bestc = c;
            bestdist = dist;
        }
    }

    if (bestc == -1) return false;

    newcam = bestc;
    return true;
}

function Vector FindFloatingCam(Pawn target)
{
    local Vector v1, v2, d;
    local Rotator r;
    local Vector hitloc, hitnormal;
    local Actor hitactor;
    local int tries;

    while (tries++ < 10)
    {
        v1 = target.Location;
        r = target.Rotation;
        r.Pitch = FRand()*12000 - 2000;
        if (VSize(target.Velocity) < 100)
            r.Yaw += FRand()*24000;
        else
            r.Yaw += FRand()*12000;
        d = Vector(r);
        v2 = v1 + d*2000;
        v1 += d*50;

        hitactor = Trace(hitloc, hitnormal, v2, v1, false);

        if (hitactor != None && VSize(hitloc - v1) > 250)
        {
            return (hitloc - d*50);
        }
    }
    // no good spots found, return something reasonable
    if (hitactor != None)
        return (hitloc - d*50);
    else
        return v2;
}

function Pawn PickNextBot(Pawn current)
{
    local Controller con;
    local int b;

    if (current != None) con = current.Controller;
    for (b=0; b<Level.Game.NumBots; b++)
    {
        if (con != None) con = con.NextController;
        if (con == None) con = Level.ControllerList;
        if (con.IsA('Bot') && con.Pawn != None && !con.IsInState('PlayerWaiting'))
        {
            return con.Pawn;
        }
    }
    return None;
}

function bool LineOfSight(int c, Pawn target)
{
    local vector v1, v2;
    local AttractCamera cam;
    local Vector hitloc, hitnormal;

    if (c >= 0) {
        cam = camlist[c];
        v1 = cam.location;
    } else {
        v1 = self.location;
    }
    v2 = target.location;
    v2.z += target.eyeheight;
    v2 += Normal(v1 - v2) * 100;
    return (Trace(hitloc, hitnormal, v1, v2, false) == None);
}

function Rotator CameraTrack(Pawn target, float DeltaTime)
{
    local float dist;
    local Vector lead;
    local float minzoomdist, maxzoomdist, viewangle, viewwidth;

    // update focuspoint
    lead = target.location + Vect(0,0,2) * Target.CollisionHeight; // + target.Velocity*0.5;
    dist = VSize(lead - focuspoint);
    if (dist > 20)
    {
        focuspoint += Normal(lead - focuspoint) * dist * DeltaTime * 2.0;
    }

    // adjust zoom within bounds (FovAngle 30-100)
    if (autozoom)
    {
        dist = VSize(Location - target.Location);

        if (curcam >= 0)
        {
            minzoomdist = camlist[curcam].minzoomdist;
            maxzoomdist = camlist[curcam].maxzoomdist;
            viewangle = camlist[curcam].ViewAngle;
        }
        else
        {
            minzoomdist = 600;
            maxzoomdist = 1200;
            viewangle = default.FovAngle;
        }

        if (dist < minzoomdist)
        {
            FovAngle = viewangle;
        }
        else if (dist < maxzoomdist)
        {
            viewwidth = minzoomdist*Tan(viewangle*PI/180 / 2);
            FovAngle = Atan(viewwidth, dist) * 180/PI * 2;
        }

        DesiredFOV = FovAngle;
    }

    return Rotator(focuspoint - location);
}

function PawnDied(Pawn P)
{
    if ( Pawn != P )
        return;
    bBehindview = true;
    LastKillTime = -5.0;

    if (Pawn != None)
    {
        curcam = -1;
        SetLocation(FindFloatingCam(Pawn));
        SetRotation(CameraTrack(Pawn, 0));
    }

    Super.PawnDied(P);
}

function SetPawnClass(string inClass, string inCharacter)
{
    local class<xPawn> pClass;

    if ( inClass != "" )
    {
        pClass = class<xPawn>(DynamicLoadObject(inClass, class'Class'));
        if ( (pClass != None) && pClass.Default.bCanPickupInventory )
            PawnClass = pClass;
    }

    PawnSetupRecord = class'xUtil'.static.FindPlayerRecord(inCharacter);
    PlayerReplicationInfo.SetCharacterName(inCharacter);
}

function SetPawnFemale()
{
    if ( PawnSetupRecord.Species == None )
        PlayerReplicationInfo.bIsFemale = true;
}

function Possess( Pawn aPawn )
{
    local xPawn xp;

    Super.Possess( aPawn );

    xp = xPawn(aPawn);
    if(xp != None)
        xp.Setup(PawnSetupRecord, true);
    if ( Level.NetMode != NM_DedicatedServer )
        ServerSetClassicTrans(bClassicTrans);
}

// for changing character on the fly (for next respawn)
exec function ChangeCharacter(string newCharacter)
{
    SetPawnClass(string(PawnClass), newCharacter);
    UpdateURL("Character", newCharacter, true);
    SaveConfig();
}

simulated function bool NeedNetNotify()
{
    return Super.NeedNetNotify() || bWaitingForPRI || (bVoiceChatEnabled && bWaitingForVRI);
}

simulated event PostNetReceive()
{
    local xUtil.PlayerRecord rec;

    Super.PostNetReceive();

    if ( PlayerReplicationInfo != None && bWaitingForPRI )
    {
        bWaitingForPRI = False;

        rec = class'xUtil'.static.FindPlayerRecord(PlayerReplicationInfo.CharacterName);
        if ( rec.Species != None )
        {
            if ( PlayerReplicationInfo.Team == None )
                rec.Species.static.LoadResources(rec, Level, PlayerReplicationInfo, 255);
            else
                rec.Species.static.LoadResources(rec, Level, PlayerReplicationInfo, PlayerReplicationInfo.Team.TeamIndex);
        }

        // Handle auto Demo Recording

        if ( bAutoDemoRec && level.NetMode==NM_Client && !bDemoOwner )
            Player.Console.DelayedConsoleCommand("demorec");
    }

    if ( VoiceReplicationInfo != None && bWaitingForVRI )
    {
        if ( PlayerReplicationInfo != None && !PlayerReplicationInfo.NeedNetNotify() )
        {
            bWaitingForVRI = VoiceReplicationInfo.GetPublicChannelCount(true) == 0;
            if ( !bWaitingForVRI )
            {
                VoiceReplicationInfo.SetOwner(Self);
                if ( bVoiceChatEnabled )
                    InitializeVoiceChat();
                else DisableVoiceChat();
            }
        }
    }

    bNetNotify = NeedNetNotify();
}

exec function AdminMenu( string CommandLine )
{
}

function ServerRequestPlayerInfo()
{
    local Controller C;
    local xPlayer xPC;

    if (PlayerReplicationInfo.bAdmin)
    {
        for (C=Level.ControllerList;C!=None;C=C.NextController)
        {
            xPC = XPlayer(C);
            if (xPC!=None)
                ClientReceiveRule(xPC.PlayerReplicationInfo.PlayerName$chr(27)$xPC.GetPlayerIDHash()$chr(27)$xPC.GetPlayerNetworkAddress());
            else
                ClientReceiveRule(C.PlayerReplicationInfo.PlayerName$chr(27)$"AI Controlled"$chr(27)$"BOT");
        }
    }
    ClientReceiveRule("Done");
}

exec function SpecViewGoal()
{
    ServerSpecViewGoal();
}

function ServerSpecViewGoal()
{
    local actor NewGoal;

    if ( PlayerReplicationInfo.bOnlySpectator && IsInState('Spectating') )
    {
        NewGoal = Level.Game.FindSpecGoalFor(PlayerReplicationInfo,0);
        if (NewGoal!=None)
        {
            if ( Pawn(NewGoal)!=None )
            {
                SetViewTarget(NewGoal);
                ClientSetViewTarget(NewGoal);
                bBehindView = true; //bChaseCam;
            }
            else
            {
                SetViewTarget(None);
                ClientSetViewTarget(None);
                bBehindView = false;

                SetLocation(NewGoal.Location);
                ClientSetLocation(NewGoal.Location,Rotation);
            }
        }
    }
}

// =====================================================================================================================
// =====================================================================================================================
//  Chat Manager
// =====================================================================================================================
// =====================================================================================================================
function ServerRequestBanInfo(int PlayerID)
{
    local array<PlayerController> CArr;
    local int i;
    //log(Name@"ServerRequestBanInfo:"$PlayerID,'ChatManager');
    if ( Level != None && Level.Game != None )
    {
        Level.Game.GetPlayerControllerList(CArr);
        for (i = 0; i < CArr.Length; i++)
        {
            // Don't send our own info
            if ( CArr[i] == Self )
                continue;

            //log(Name@"ServerRequestBanInfo CArr["$i$"]:"$CArr[i]@"ID:"$CArr[i].PlayerReplicationInfo.PlayerID,'ChatManager');
            if ( PlayerID == -1 || CArr[i].PlayerReplicationInfo.PlayerID == PlayerID )
            {
                log(Name@"Sending BanInfo To Client PlayerID:"$CArr[i].PlayerReplicationInfo.PlayerID@"Hash:"$CArr[i].GetPlayerIDHash()@"Address:"$CArr[i].GetPlayerNetworkAddress(),'ChatManager');
                ChatManager.TrackNewPlayer(CArr[i].PlayerReplicationInfo.PlayerID, CArr[i].GetPlayerIDHash(), CArr[i].GetPlayerNetworkAddress());
                ClientReceiveBan(CArr[i].PlayerReplicationInfo.PlayerID$Chr(27)$CArr[i].GetPlayerIDHash()$chr(27)$CArr[i].GetPlayerNetworkAddress());
            }
        }
    }
}

function ClientReceiveBan(string BanInfo)
{
    if ( UnrealPlayerChatManager(ChatManager) != None )
        UnrealPlayerChatManager(ChatManager).ReceiveBanInfo(BanInfo);
}


// =====================================================================================================================
// =====================================================================================================================
//  Voice Chat
// =====================================================================================================================
// =====================================================================================================================
simulated function InitializeVoiceChat()
{
    Super.InitializeVoiceChat();

    // Check player hashes for all players on the server
    ServerRequestBanInfo(-1);
}

simulated exec function ShowAliases()
{
    local array<string> Output;
    local Security S;
    local int i;

    S = Spawn(class'Engine.Security');
    if (S!=None)
    {
        S.LocalPerform(100,"","",Output);
        Log("No of Aliases:"@Output.Length);
        for (i=0;i<Output.Length;i++)
          log("   Alias"@i$":"@Output[i]);

        S.Destroy();
    }
}

simulated exec function ShowBindings()
{
    local array<string> Output;
    local Security S;
    local int i;

    S = Spawn(class'Engine.Security');
    if (S!=None)
    {
        S.LocalPerform(101,"","",Output);
        Log("No of Bindings:"@Output.Length);
        for (i=0;i<Output.Length;i++)
          log("   Binding"@i$":"@Output[i]);

        S.Destroy();
    }
}

exec function check()
{
    local decoration d;
    foreach allactors(class'decoration',d)
        log("#### D:"@D@vsize(pawn.location - d.location));
}

defaultproperties
{
     curcam=-1
     MinAdrenalineCost=100.000000
     ComboNameList(0)="XGame.ComboSpeed"
     ComboNameList(1)="XGame.ComboBerserk"
     ComboNameList(2)="XGame.ComboDefensive"
     ComboNameList(3)="XGame.ComboInvis"
     bWaitingForPRI=Wahr
     bWaitingForVRI=Wahr
     TeamBeaconTexture=Texture'TeamSymbols.TeamBeaconT'
     LinkBeaconTexture=Texture'TeamSymbols.LinkBeaconT'
     SpeakingBeaconTexture=Texture'TeamSymbols.soundBeacon_a00'
     PlayerReplicationInfoClass=Class'XGame.xPlayerReplicationInfo'
     PawnClass=Class'XGame.xPawn'
     bNetNotify=Wahr
}