codemp/cgame/cg_draw.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_draw.c -- draw all of the graphical elements during
// active (after loading) gameplay

#include "cg_local.h"

#include "bg_saga.h"

#include "../ui/ui_shared.h"
#include "../ui/ui_public.h"

extern float CG_RadiusForCent( centity_t *cent );
qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y);
qboolean CG_CalcMuzzlePoint( int entityNum, vec3_t muzzle );
static void CG_DrawSiegeTimer(int timeRemaining, qboolean isMyTeam);
static void CG_DrawSiegeDeathTimer( int timeRemaining );
// nmckenzie: DUEL_HEALTH
void CG_DrawDuelistHealth ( float x, float y, float w, float h, int duelist );

// used for scoreboard
extern displayContextDef_t cgDC;
menuDef_t *menuScoreboard = NULL;
vec4_t  bluehudtint = {0.5, 0.5, 1.0, 1.0};
vec4_t  redhudtint = {1.0, 0.5, 0.5, 1.0};
float   *hudTintColor;

int sortedTeamPlayers[TEAM_MAXOVERLAY];
int     numSortedTeamPlayers;

int lastvalidlockdif;

extern float zoomFov; //this has to be global client-side

char systemChat[256];
char teamChat1[256];
char teamChat2[256];

// The time at which you died and the time it will take for you to rejoin game.
int cg_siegeDeathTime = 0;

#define MAX_HUD_TICS 4
const char *armorTicName[MAX_HUD_TICS] = 
{
"armor_tic1", 
"armor_tic2", 
"armor_tic3", 
"armor_tic4", 
};

const char *healthTicName[MAX_HUD_TICS] = 
{
"health_tic1", 
"health_tic2", 
"health_tic3", 
"health_tic4", 
};

const char *forceTicName[MAX_HUD_TICS] = 
{
"force_tic1", 
"force_tic2", 
"force_tic3", 
"force_tic4", 
};

const char *ammoTicName[MAX_HUD_TICS] = 
{
"ammo_tic1", 
"ammo_tic2", 
"ammo_tic3", 
"ammo_tic4", 
};

char *showPowersName[] = 
{
        "HEAL2",//FP_HEAL
        "JUMP2",//FP_LEVITATION
        "SPEED2",//FP_SPEED
        "PUSH2",//FP_PUSH
        "PULL2",//FP_PULL
        "MINDTRICK2",//FP_TELEPTAHY
        "GRIP2",//FP_GRIP
        "LIGHTNING2",//FP_LIGHTNING
        "DARK_RAGE2",//FP_RAGE
        "PROTECT2",//FP_PROTECT
        "ABSORB2",//FP_ABSORB
        "TEAM_HEAL2",//FP_TEAM_HEAL
        "TEAM_REPLENISH2",//FP_TEAM_FORCE
        "DRAIN2",//FP_DRAIN
        "SEEING2",//FP_SEE
        "SABER_OFFENSE2",//FP_SABER_OFFENSE
        "SABER_DEFENSE2",//FP_SABER_DEFENSE
        "SABER_THROW2",//FP_SABERTHROW
        NULL
};

//Called from UI shared code. For now we'll just redirect to the normal anim load function.
#include "../namespace_begin.h"


int UI_ParseAnimationFile(const char *filename, animation_t *animset, qboolean isHumanoid) 
{
        return BG_ParseAnimationFile(filename, animset, isHumanoid);
}

int MenuFontToHandle(int iMenuFont)
{
        switch (iMenuFont)
        {
                case FONT_SMALL:        return cgDC.Assets.qhSmallFont;
                case FONT_SMALL2:       return cgDC.Assets.qhSmall2Font;
                case FONT_MEDIUM:       return cgDC.Assets.qhMediumFont;
                case FONT_LARGE:        return cgDC.Assets.qhMediumFont;//cgDC.Assets.qhBigFont;
                        //fixme? Big fonr isn't registered...?
        }

        return cgDC.Assets.qhMediumFont;
}

#include "../namespace_end.h"

int CG_Text_Width(const char *text, float scale, int iMenuFont) 
{
        int iFontIndex = MenuFontToHandle(iMenuFont);

        return trap_R_Font_StrLenPixels(text, iFontIndex, scale);
}

int CG_Text_Height(const char *text, float scale, int iMenuFont) 
{
        int iFontIndex = MenuFontToHandle(iMenuFont);

        return trap_R_Font_HeightPixels(iFontIndex, scale);
}

#include "../qcommon/qfiles.h"  // for STYLE_BLINK etc
void CG_Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont) 
{
        int iStyleOR = 0;
        int iFontIndex = MenuFontToHandle(iMenuFont);
        
        switch (style)
        {
        case  ITEM_TEXTSTYLE_NORMAL:                    iStyleOR = 0;break;                                     // JK2 normal text
        case  ITEM_TEXTSTYLE_BLINK:                             iStyleOR = STYLE_BLINK;break;           // JK2 fast blinking
        case  ITEM_TEXTSTYLE_PULSE:                             iStyleOR = STYLE_BLINK;break;           // JK2 slow pulsing
        case  ITEM_TEXTSTYLE_SHADOWED:                  iStyleOR = (int)STYLE_DROPSHADOW;break; // JK2 drop shadow ( need a color for this )
        case  ITEM_TEXTSTYLE_OUTLINED:                  iStyleOR = (int)STYLE_DROPSHADOW;break; // JK2 drop shadow ( need a color for this )
        case  ITEM_TEXTSTYLE_OUTLINESHADOWED:   iStyleOR = (int)STYLE_DROPSHADOW;break; // JK2 drop shadow ( need a color for this )
        case  ITEM_TEXTSTYLE_SHADOWEDMORE:              iStyleOR = (int)STYLE_DROPSHADOW;break; // JK2 drop shadow ( need a color for this )
        }

        trap_R_Font_DrawString( x,              // int ox
                                                        y,              // int oy
                                                        text,   // const char *text
                                                        color,  // paletteRGBA_c c
                                                        iStyleOR | iFontIndex,  // const int iFontHandle
                                                        !limit?-1:limit,                // iCharLimit (-1 = none)
                                                        scale   // const float scale = 1.0f
                                                        );
}

/*
qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y)

  Take any world coord and convert it to a 2D virtual 640x480 screen coord
*/
/*
qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
{
        int     xcenter, ycenter;
        vec3_t  local, transformed;

//      xcenter = cg.refdef.width / 2;//gives screen coords adjusted for resolution
//      ycenter = cg.refdef.height / 2;//gives screen coords adjusted for resolution
        
        //NOTE: did it this way because most draw functions expect virtual 640x480 coords
        //      and adjust them for current resolution
        xcenter = 640 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn
        ycenter = 480 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn

        VectorSubtract (worldCoord, cg.refdef.vieworg, local);

        transformed[0] = DotProduct(local,vright);
        transformed[1] = DotProduct(local,vup);
        transformed[2] = DotProduct(local,vfwd);                

        // Make sure Z is not negative.
        if(transformed[2] < 0.01)
        {
                return qfalse;
        }
        // Simple convert to screen coords.
        float xzi = xcenter / transformed[2] * (90.0/cg.refdef.fov_x);
        float yzi = ycenter / transformed[2] * (90.0/cg.refdef.fov_y);

        *x = xcenter + xzi * transformed[0];
        *y = ycenter - yzi * transformed[1];

        return qtrue;
}

qboolean CG_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
{
        float   xF, yF;
        qboolean retVal = CG_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
        *x = (int)xF;
        *y = (int)yF;
        return retVal;
}
*/

/*
================
CG_DrawZoomMask

================
*/
static void CG_DrawZoomMask( void )
{
        vec4_t          color1;
        float           level;
        static qboolean flip = qtrue;

//      int ammo = cg_entities[0].gent->client->ps.ammo[weaponData[cent->currentState.weapon].ammoIndex];
        float cx, cy;
//      int val[5];
        float max, fi;

        // Check for Binocular specific zooming since we'll want to render different bits in each case
        if ( cg.predictedPlayerState.zoomMode == 2 )
        {
                int val, i;
                float off;

                // zoom level
                level = (float)(80.0f - cg.predictedPlayerState.zoomFov) / 80.0f;

                // ...so we'll clamp it
                if ( level < 0.0f )
                {
                        level = 0.0f;
                }
                else if ( level > 1.0f )
                {
                        level = 1.0f;
                }

                // Using a magic number to convert the zoom level to scale amount
                level *= 162.0f;

                // draw blue tinted distortion mask, trying to make it as small as is necessary to fill in the viewable area
                trap_R_SetColor( colorTable[CT_WHITE] );
                CG_DrawPic( 34, 48, 570, 362, cgs.media.binocularStatic );
        
                // Black out the area behind the numbers
                trap_R_SetColor( colorTable[CT_BLACK]);
                CG_DrawPic( 212, 367, 200, 40, cgs.media.whiteShader );

                // Numbers should be kind of greenish
                color1[0] = 0.2f;
                color1[1] = 0.4f;
                color1[2] = 0.2f;
                color1[3] = 0.3f;
                trap_R_SetColor( color1 );

                // Draw scrolling numbers, use intervals 10 units apart--sorry, this section of code is just kind of hacked
                //      up with a bunch of magic numbers.....
                val = ((int)((cg.refdef.viewangles[YAW] + 180) / 10)) * 10;
                off = (cg.refdef.viewangles[YAW] + 180) - val;

                for ( i = -10; i < 30; i += 10 )
                {
                        val -= 10;

                        if ( val < 0 )
                        {
                                val += 360;
                        }

                        // we only want to draw the very far left one some of the time, if it's too far to the left it will
                        //      poke outside the mask.
                        if (( off > 3.0f && i == -10 ) || i > -10 )
                        {
                                // draw the value, but add 200 just to bump the range up...arbitrary, so change it if you like
                                CG_DrawNumField( 155 + i * 10 + off * 10, 374, 3, val + 200, 24, 14, NUM_FONT_CHUNKY, qtrue );
                                CG_DrawPic( 245 + (i-1) * 10 + off * 10, 376, 6, 6, cgs.media.whiteShader );
                        }
                }

                CG_DrawPic( 212, 367, 200, 28, cgs.media.binocularOverlay );

                color1[0] = sin( cg.time * 0.01f ) * 0.5f + 0.5f;
                color1[0] = color1[0] * color1[0];
                color1[1] = color1[0];
                color1[2] = color1[0];
                color1[3] = 1.0f;

                trap_R_SetColor( color1 );

                CG_DrawPic( 82, 94, 16, 16, cgs.media.binocularCircle );

                // Flickery color
                color1[0] = 0.7f + crandom() * 0.1f;
                color1[1] = 0.8f + crandom() * 0.1f;
                color1[2] = 0.7f + crandom() * 0.1f;
                color1[3] = 1.0f;
                trap_R_SetColor( color1 );
        
                CG_DrawPic( 0, 0, 640, 480, cgs.media.binocularMask );

                CG_DrawPic( 4, 282 - level, 16, 16, cgs.media.binocularArrow );

                // The top triangle bit randomly flips 
                if ( flip )
                {
                        CG_DrawPic( 330, 60, -26, -30, cgs.media.binocularTri );
                }
                else
                {
                        CG_DrawPic( 307, 40, 26, 30, cgs.media.binocularTri );
                }

                if ( random() > 0.98f && ( cg.time & 1024 ))
                {
                        flip = !flip;
                }
        }
        else if ( cg.predictedPlayerState.zoomMode)
        {
                // disruptor zoom mode
                level = (float)(50.0f - zoomFov) / 50.0f;//(float)(80.0f - zoomFov) / 80.0f;

                // ...so we'll clamp it
                if ( level < 0.0f )
                {
                        level = 0.0f;
                }
                else if ( level > 1.0f )
                {
                        level = 1.0f;
                }

                // Using a magic number to convert the zoom level to a rotation amount that correlates more or less with the zoom artwork. 
                level *= 103.0f;

                // Draw target mask
                trap_R_SetColor( colorTable[CT_WHITE] );
                CG_DrawPic( 0, 0, 640, 480, cgs.media.disruptorMask );

                // apparently 99.0f is the full zoom level
                if ( level >= 99 )
                {
                        // Fully zoomed, so make the rotating insert pulse
                        color1[0] = 1.0f; 
                        color1[1] = 1.0f;
                        color1[2] = 1.0f;
                        color1[3] = 0.7f + sin( cg.time * 0.01f ) * 0.3f;

                        trap_R_SetColor( color1 );
                }

                // Draw rotating insert
                CG_DrawRotatePic2( 320, 240, 640, 480, -level, cgs.media.disruptorInsert );

                // Increase the light levels under the center of the target
//              CG_DrawPic( 198, 118, 246, 246, cgs.media.disruptorLight );

                // weirdness.....converting ammo to a base five number scale just to be geeky.
/*              val[0] = ammo % 5;
                val[1] = (ammo / 5) % 5;
                val[2] = (ammo / 25) % 5;
                val[3] = (ammo / 125) % 5;
                val[4] = (ammo / 625) % 5;
                
                color1[0] = 0.2f;
                color1[1] = 0.55f + crandom() * 0.1f;
                color1[2] = 0.5f + crandom() * 0.1f;
                color1[3] = 1.0f;
                trap_R_SetColor( color1 );

                for ( int t = 0; t < 5; t++ )
                {
                        cx = 320 + sin( (t*10+45)/57.296f ) * 192;
                        cy = 240 + cos( (t*10+45)/57.296f ) * 192;

                        CG_DrawRotatePic2( cx, cy, 24, 38, 45 - t * 10, trap_R_RegisterShader( va("gfx/2d/char%d",val[4-t] )));
                }
*/
                //max = ( cg_entities[0].gent->health / 100.0f );

                
                if ( (cg.snap->ps.eFlags & EF_DOUBLE_AMMO) )
                {
                        max = cg.snap->ps.ammo[weaponData[WP_DISRUPTOR].ammoIndex] / ((float)ammoData[weaponData[WP_DISRUPTOR].ammoIndex].max*2.0f);
                }
                else
                {
                        max = cg.snap->ps.ammo[weaponData[WP_DISRUPTOR].ammoIndex] / (float)ammoData[weaponData[WP_DISRUPTOR].ammoIndex].max;
                }
                if ( max > 1.0f )
                {
                        max = 1.0f;
                }

                color1[0] = (1.0f - max) * 2.0f; 
                color1[1] = max * 1.5f;
                color1[2] = 0.0f;
                color1[3] = 1.0f;

                // If we are low on health, make us flash
                if ( max < 0.15f && ( cg.time & 512 ))
                {
                        VectorClear( color1 );
                }

                if ( color1[0] > 1.0f )
                {
                        color1[0] = 1.0f;
                }

                if ( color1[1] > 1.0f )
                {
                        color1[1] = 1.0f;
                }

                trap_R_SetColor( color1 );

                max *= 58.0f;

                for (fi = 18.5f; fi <= 18.5f + max; fi+= 3 ) // going from 15 to 45 degrees, with 5 degree increments
                {
                        cx = 320 + sin( (fi+90.0f)/57.296f ) * 190;
                        cy = 240 + cos( (fi+90.0f)/57.296f ) * 190;

                        CG_DrawRotatePic2( cx, cy, 12, 24, 90 - fi, cgs.media.disruptorInsertTick );
                }

                if ( cg.predictedPlayerState.weaponstate == WEAPON_CHARGING_ALT )
                {
                        trap_R_SetColor( colorTable[CT_WHITE] );

                        // draw the charge level
                        max = ( cg.time - cg.predictedPlayerState.weaponChargeTime ) / ( 50.0f * 30.0f ); // bad hardcodedness 50 is disruptor charge unit and 30 is max charge units allowed.

                        if ( max > 1.0f )
                        {
                                max = 1.0f;
                        }

                        trap_R_DrawStretchPic(257, 435, 134*max, 34, 0, 0, max, 1, cgs.media.disruptorChargeShader);
                }
//              trap_R_SetColor( colorTable[CT_WHITE] );
//              CG_DrawPic( 0, 0, 640, 480, cgs.media.disruptorMask );

        }
}


/*
================
CG_Draw3DModel

================
*/
void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, void *ghoul2, int g2radius, qhandle_t skin, vec3_t origin, vec3_t angles ) {
        refdef_t                refdef;
        refEntity_t             ent;

        if ( !cg_draw3dIcons.integer || !cg_drawIcons.integer ) {
                return;
        }

        memset( &refdef, 0, sizeof( refdef ) );

        memset( &ent, 0, sizeof( ent ) );
        AnglesToAxis( angles, ent.axis );
        VectorCopy( origin, ent.origin );
        ent.hModel = model;
        ent.ghoul2 = ghoul2;
        ent.radius = g2radius;
        ent.customSkin = skin;
        ent.renderfx = RF_NOSHADOW;             // no stencil shadows

        refdef.rdflags = RDF_NOWORLDMODEL;

        AxisClear( refdef.viewaxis );

        refdef.fov_x = 30;
        refdef.fov_y = 30;

        refdef.x = x;
        refdef.y = y;
        refdef.width = w;
        refdef.height = h;

        refdef.time = cg.time;

        trap_R_ClearScene();
        trap_R_AddRefEntityToScene( &ent );
        trap_R_RenderScene( &refdef );
}

/*
================
CG_DrawHead

Used for both the status bar and the scoreboard
================
*/
void CG_DrawHead( float x, float y, float w, float h, int clientNum, vec3_t headAngles ) 
{
        clientInfo_t    *ci;

        if (clientNum >= MAX_CLIENTS)
        { //npc?
                return;
        }

        ci = &cgs.clientinfo[ clientNum ];

        CG_DrawPic( x, y, w, h, ci->modelIcon );

        // if they are deferred, draw a cross out
        if ( ci->deferred ) 
        {
                CG_DrawPic( x, y, w, h, cgs.media.deferShader );
        }
}

/*
================
CG_DrawFlagModel

Used for both the status bar and the scoreboard
================
*/
void CG_DrawFlagModel( float x, float y, float w, float h, int team, qboolean force2D ) {
        qhandle_t               cm;
        float                   len;
        vec3_t                  origin, angles;
        vec3_t                  mins, maxs;
        qhandle_t               handle;

        if ( !force2D && cg_draw3dIcons.integer ) {

                VectorClear( angles );

                cm = cgs.media.redFlagModel;

                // offset the origin y and z to center the flag
                trap_R_ModelBounds( cm, mins, maxs );

                origin[2] = -0.5 * ( mins[2] + maxs[2] );
                origin[1] = 0.5 * ( mins[1] + maxs[1] );

                // calculate distance so the flag nearly fills the box
                // assume heads are taller than wide
                len = 0.5 * ( maxs[2] - mins[2] );              
                origin[0] = len / 0.268;        // len / tan( fov/2 )

                angles[YAW] = 60 * sin( cg.time / 2000.0 );;

                if( team == TEAM_RED ) {
                        handle = cgs.media.redFlagModel;
                } else if( team == TEAM_BLUE ) {
                        handle = cgs.media.blueFlagModel;
                } else if( team == TEAM_FREE ) {
                        handle = 0;//cgs.media.neutralFlagModel;
                } else {
                        return;
                }
                CG_Draw3DModel( x, y, w, h, handle, NULL, 0, 0, origin, angles );
        } else if ( cg_drawIcons.integer ) {
                gitem_t *item;

                if( team == TEAM_RED ) {
                        item = BG_FindItemForPowerup( PW_REDFLAG );
                } else if( team == TEAM_BLUE ) {
                        item = BG_FindItemForPowerup( PW_BLUEFLAG );
                } else if( team == TEAM_FREE ) {
                        item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
                } else {
                        return;
                }
                if (item) {
                  CG_DrawPic( x, y, w, h, cg_items[ ITEM_INDEX(item) ].icon );
                }
        }
}

/*
================
DrawAmmo
================
*/
void DrawAmmo()
{
        int x, y;

        x = SCREEN_WIDTH-80;
        y = SCREEN_HEIGHT-80;

}



/*
================
CG_DrawHealth
================
*/
void CG_DrawHealth( menuDef_t *menuHUD )
{
        vec4_t                  calcColor;
        playerState_t   *ps;
        int                             healthAmt;
        int                             i,currValue,inc;
        itemDef_t               *focusItem;
        float percent;

        // Can we find the menu?
        if (!menuHUD)
        {
                return;
        }

        ps = &cg.snap->ps;

        // What's the health?
        healthAmt = ps->stats[STAT_HEALTH];
        if (healthAmt > ps->stats[STAT_MAX_HEALTH])
        {
                healthAmt = ps->stats[STAT_MAX_HEALTH];
        }


        inc = (float) ps->stats[STAT_MAX_HEALTH] / MAX_HUD_TICS;
        currValue = healthAmt;

        // Print the health tics, fading out the one which is partial health
        for (i=(MAX_HUD_TICS-1);i>=0;i--)
        {
                focusItem = Menu_FindItemByName(menuHUD, healthTicName[i]);

                if (!focusItem) // This is bad
                {
                        continue;
                }

                memcpy(calcColor, hudTintColor, sizeof(vec4_t));

                if (currValue <= 0)     // don't show tic
                {
                        break;
                }
                else if (currValue < inc)       // partial tic (alpha it out)
                {
                        percent = (float) currValue / inc;
                        calcColor[3] *= percent;                // Fade it out
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        focusItem->window.rect.x,
                        focusItem->window.rect.y,
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        focusItem->window.background
                        );

                currValue -= inc;
        }

        // Print the mueric amount
        focusItem = Menu_FindItemByName(menuHUD, "healthamount");
        if (focusItem)
        {
                // Print health amount
                trap_R_SetColor( focusItem->window.foreColor ); 

                CG_DrawNumField (
                        focusItem->window.rect.x, 
                        focusItem->window.rect.y, 
                        3, 
                        ps->stats[STAT_HEALTH], 
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        NUM_FONT_SMALL,
                        qfalse);
        }

}

/*
================
CG_DrawArmor
================
*/
void CG_DrawArmor( menuDef_t *menuHUD )
{
        vec4_t                  calcColor;
        playerState_t   *ps;
        int                             armor, maxArmor;
        itemDef_t               *focusItem;
        float                   percent,quarterArmor;
        int                             i,currValue,inc;

        //ps = &cg.snap->ps;
        ps = &cg.predictedPlayerState;

        // Can we find the menu?
        if (!menuHUD)
        {
                return;
        }

        armor = ps->stats[STAT_ARMOR];
        maxArmor = ps->stats[STAT_MAX_HEALTH];

        if (armor> maxArmor)
        {
                armor = maxArmor;
        }

        currValue = armor;
        inc = (float) maxArmor / MAX_HUD_TICS;

        memcpy(calcColor, hudTintColor, sizeof(vec4_t));
        for (i=(MAX_HUD_TICS-1);i>=0;i--)
        {
                focusItem = Menu_FindItemByName(menuHUD, armorTicName[i]);

                if (!focusItem) // This is bad
                {
                        continue;
                }

                memcpy(calcColor, hudTintColor, sizeof(vec4_t));

                if (currValue <= 0)     // don't show tic
                {
                        break;
                }
                else if (currValue < inc)       // partial tic (alpha it out)
                {
                        percent = (float) currValue / inc;
                        calcColor[3] *= percent;
                }

                trap_R_SetColor( calcColor);

                if ((i==(MAX_HUD_TICS-1)) && (currValue < inc))
                {
                        if (cg.HUDArmorFlag)
                        {
                                CG_DrawPic( 
                                        focusItem->window.rect.x,
                                        focusItem->window.rect.y,
                                        focusItem->window.rect.w, 
                                        focusItem->window.rect.h, 
                                        focusItem->window.background
                                        );
                        }
                }
                else 
                {
                                CG_DrawPic( 
                                        focusItem->window.rect.x,
                                        focusItem->window.rect.y,
                                        focusItem->window.rect.w, 
                                        focusItem->window.rect.h, 
                                        focusItem->window.background
                                        );
                }

                currValue -= inc;
        }

        focusItem = Menu_FindItemByName(menuHUD, "armoramount");

        if (focusItem)
        {
                // Print armor amount
                trap_R_SetColor( focusItem->window.foreColor ); 

                CG_DrawNumField (
                        focusItem->window.rect.x, 
                        focusItem->window.rect.y, 
                        3, 
                        armor, 
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        NUM_FONT_SMALL,
                        qfalse);
        }

        // If armor is low, flash a graphic to warn the player
        if (armor)      // Is there armor? Draw the HUD Armor TIC
        {
                quarterArmor = (float) (ps->stats[STAT_MAX_HEALTH] / 4.0f);

                // Make tic flash if armor is at 25% of full armor
                if (ps->stats[STAT_ARMOR] < quarterArmor)               // Do whatever the flash timer says
                {
                        if (cg.HUDTickFlashTime < cg.time)                      // Flip at the same time
                        {
                                cg.HUDTickFlashTime = cg.time + 400;
                                if (cg.HUDArmorFlag)
                                {
                                        cg.HUDArmorFlag = qfalse;
                                }
                                else
                                {
                                        cg.HUDArmorFlag = qtrue;
                                }
                        }
                }
                else
                {
                        cg.HUDArmorFlag=qtrue;
                }
        }
        else                                            // No armor? Don't show it.
        {
                cg.HUDArmorFlag=qfalse;
        }

}

/*
================
CG_DrawSaberStyle

If the weapon is a light saber (which needs no ammo) then draw a graphic showing
the saber style (fast, medium, strong)
================
*/
static void CG_DrawSaberStyle( centity_t *cent, menuDef_t *menuHUD)
{
        itemDef_t               *focusItem;

        if (!cent->currentState.weapon ) // We don't have a weapon right now
        {
                return;
        }

        if ( cent->currentState.weapon != WP_SABER )
        {
                return;
        }

        // Can we find the menu?
        if (!menuHUD)
        {
                return;
        }


        // draw the current saber style in this window
        switch ( cg.predictedPlayerState.fd.saberDrawAnimLevel )
        {
        case 1://FORCE_LEVEL_1:
        case 5://FORCE_LEVEL_5://Tavion

                focusItem = Menu_FindItemByName(menuHUD, "saberstyle_fast");

                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );

                        CG_DrawPic( 
                                focusItem->window.rect.x,
                                focusItem->window.rect.y,
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background
                                );
                }

                break;
        case 2://FORCE_LEVEL_2:
        case 6://SS_DUAL
        case 7://SS_STAFF
                focusItem = Menu_FindItemByName(menuHUD, "saberstyle_medium");

                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );

                        CG_DrawPic( 
                                focusItem->window.rect.x,
                                focusItem->window.rect.y,
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background
                                );
                }
                break;
        case 3://FORCE_LEVEL_3:
        case 4://FORCE_LEVEL_4://Desann
                focusItem = Menu_FindItemByName(menuHUD, "saberstyle_strong");

                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );

                        CG_DrawPic( 
                                focusItem->window.rect.x,
                                focusItem->window.rect.y,
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background
                                );
                }
                break;
        }

}

/*
================
CG_DrawAmmo
================
*/
static void CG_DrawAmmo( centity_t      *cent,menuDef_t *menuHUD)
{
        playerState_t   *ps;
        int                             i;
        vec4_t                  calcColor;
        float                   value,inc = 0.0f,percent;
        itemDef_t               *focusItem;

        ps = &cg.snap->ps;

        // Can we find the menu?
        if (!menuHUD)
        {
                return;
        }

        if (!cent->currentState.weapon ) // We don't have a weapon right now
        {
                return;
        }

        value = ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
        if (value < 0)  // No ammo
        {
                return;
        }

        focusItem = Menu_FindItemByName(menuHUD, "ammoamount");
        trap_R_SetColor( hudTintColor );

        if (weaponData[cent->currentState.weapon].energyPerShot == 0 &&
                weaponData[cent->currentState.weapon].altEnergyPerShot == 0)
        { //just draw "infinite"
                inc = 8 / MAX_HUD_TICS;
                value = 8;

                focusItem = Menu_FindItemByName(menuHUD, "ammoinfinite");
                trap_R_SetColor( hudTintColor );
                if (focusItem)
                {
                        UI_DrawProportionalString(focusItem->window.rect.x, focusItem->window.rect.y, "--", NUM_FONT_SMALL, focusItem->window.foreColor);
                }
        }
        else
        {
                focusItem = Menu_FindItemByName(menuHUD, "ammoamount");
                trap_R_SetColor( hudTintColor );
                if (focusItem)
                {

                        if ( (cent->currentState.eFlags & EF_DOUBLE_AMMO) )
                        {
                                inc = (float) (ammoData[weaponData[cent->currentState.weapon].ammoIndex].max*2.0f) / MAX_HUD_TICS;
                        }
                        else
                        {
                                inc = (float) ammoData[weaponData[cent->currentState.weapon].ammoIndex].max / MAX_HUD_TICS;
                        }
                        value =ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];

                        CG_DrawNumField (
                                focusItem->window.rect.x, 
                                focusItem->window.rect.y, 
                                3, 
                                value, 
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                NUM_FONT_SMALL,
                                qfalse);
                }
        }

        // Draw tics
        for (i=MAX_HUD_TICS-1;i>=0;i--)
        {
                focusItem = Menu_FindItemByName(menuHUD, ammoTicName[i]);

                if (!focusItem)
                {
                        continue;
                }

                memcpy(calcColor, hudTintColor, sizeof(vec4_t));

                if ( value <= 0 )       // done
                {
                        break;
                }
                else if (value < inc)   // partial tic
                {
                        percent = value / inc;
                        calcColor[3] = percent;
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        focusItem->window.rect.x,
                        focusItem->window.rect.y,
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        focusItem->window.background
                        );

                value -= inc;
        }

}

/*
================
CG_DrawForcePower
================
*/
void CG_DrawForcePower( menuDef_t *menuHUD )
{
        int                             i;
        vec4_t                  calcColor;
        float                   value,inc,percent;
        itemDef_t               *focusItem;
        const int               maxForcePower = 100;
        qboolean        flash=qfalse;

        // Can we find the menu?
        if (!menuHUD)
        {
                return;
        }

        // Make the hud flash by setting forceHUDTotalFlashTime above cg.time
        if (cg.forceHUDTotalFlashTime > cg.time )
        {
                flash = qtrue;
                if (cg.forceHUDNextFlashTime < cg.time) 
                {
                        cg.forceHUDNextFlashTime = cg.time + 400;
                        trap_S_StartSound (NULL, 0, CHAN_LOCAL, cgs.media.noforceSound );

                        if (cg.forceHUDActive)
                        {
                                cg.forceHUDActive = qfalse;
                        }
                        else
                        {
                                cg.forceHUDActive = qtrue;
                        }

                }
        }
        else    // turn HUD back on if it had just finished flashing time.
        {
                cg.forceHUDNextFlashTime = 0;
                cg.forceHUDActive = qtrue;
        }

//      if (!cg.forceHUDActive)
//      {
//              return;
//      }

        inc = (float)  maxForcePower / MAX_HUD_TICS;
        value = cg.snap->ps.fd.forcePower;

        for (i=MAX_HUD_TICS-1;i>=0;i--)
        {
                focusItem = Menu_FindItemByName(menuHUD, forceTicName[i]);

                if (!focusItem)
                {
                        continue;
                }

//              memcpy(calcColor, hudTintColor, sizeof(vec4_t));

                if ( value <= 0 )       // done
                {
                        break;
                }
                else if (value < inc)   // partial tic
                {
                        if (flash)
                        {
                                memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
                        }
                        else 
                        {
                                memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
                        }

                        percent = value / inc;
                        calcColor[3] = percent;
                }
                else
                {
                        if (flash)
                        {
                                memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
                        }
                        else 
                        {
                                memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
                        }
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        focusItem->window.rect.x,
                        focusItem->window.rect.y,
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        focusItem->window.background
                        );

                value -= inc;
        }

        focusItem = Menu_FindItemByName(menuHUD, "forceamount");

        if (focusItem)
        {
                // Print force amount
                trap_R_SetColor( focusItem->window.foreColor ); 

                CG_DrawNumField (
                        focusItem->window.rect.x, 
                        focusItem->window.rect.y, 
                        3, 
                        cg.snap->ps.fd.forcePower, 
                        focusItem->window.rect.w, 
                        focusItem->window.rect.h, 
                        NUM_FONT_SMALL,
                        qfalse);
        }
}

/*
================
CG_DrawHUD
================
*/
void CG_DrawHUD(centity_t       *cent)
{
        menuDef_t       *menuHUD = NULL;
        itemDef_t       *focusItem = NULL;
        const char *scoreStr = NULL;
        int     scoreBias;
        char scoreBiasStr[16];

        if (cg_hudFiles.integer)
        {
                int x = 0;
                int y = SCREEN_HEIGHT-80;
                char ammoString[64];
                int weapX = x;

                UI_DrawProportionalString( x+16, y+40, va( "%i", cg.snap->ps.stats[STAT_HEALTH] ),
                        UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_RED] );

                UI_DrawProportionalString( x+18+14, y+40+14, va( "%i", cg.snap->ps.stats[STAT_ARMOR] ),
                        UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_GREEN] );

                if (cg.snap->ps.weapon == WP_SABER)
                {
                        if (cg.snap->ps.fd.saberDrawAnimLevel == SS_DUAL)
                        {
                                Com_sprintf(ammoString, sizeof(ammoString), "AKIMBO");
                                weapX += 16;
                        }
                        else if (cg.snap->ps.fd.saberDrawAnimLevel == SS_STAFF)
                        {
                                Com_sprintf(ammoString, sizeof(ammoString), "STAFF");
                                weapX += 16;
                        }
                        else if (cg.snap->ps.fd.saberDrawAnimLevel == FORCE_LEVEL_3)
                        {
                                Com_sprintf(ammoString, sizeof(ammoString), "STRONG");
                                weapX += 16;
                        }
                        else if (cg.snap->ps.fd.saberDrawAnimLevel == FORCE_LEVEL_2)
                        {
                                Com_sprintf(ammoString, sizeof(ammoString), "MEDIUM");
                                weapX += 16;
                        }
                        else
                        {
                                Com_sprintf(ammoString, sizeof(ammoString), "FAST");
                        }
                }
                else
                {
                        Com_sprintf(ammoString, sizeof(ammoString), "%i", cg.snap->ps.ammo[weaponData[cent->currentState.weapon].ammoIndex]);
                }
                
                UI_DrawProportionalString( SCREEN_WIDTH-(weapX+16+32), y+40, va( "%s", ammoString ),
                        UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_ORANGE] );

                UI_DrawProportionalString( SCREEN_WIDTH-(x+18+14+32), y+40+14, va( "%i", cg.snap->ps.fd.forcePower),
                        UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_ICON_BLUE] );

                return;
        }

        if (cgs.gametype >= GT_TEAM && cgs.gametype != GT_SIEGE)
        {       // tint the hud items based on team
                if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED )
                        hudTintColor = redhudtint;
                else if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE )
                        hudTintColor = bluehudtint;
                else // If we're not on a team for whatever reason, leave things as they are.
                        hudTintColor = colorTable[CT_WHITE];
        }
        else
        {       // tint the hud items white (dont' tint)
                hudTintColor = colorTable[CT_WHITE];
        }

        // Draw the left HUD 
        menuHUD = Menus_FindByName("lefthud");
        if (menuHUD)
        {
                itemDef_t *focusItem;

                // Print scanline
                focusItem = Menu_FindItemByName(menuHUD, "scanline");
                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );        
                        CG_DrawPic( 
                                focusItem->window.rect.x, 
                                focusItem->window.rect.y, 
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background 
                                );                      
                }

                // Print frame
                focusItem = Menu_FindItemByName(menuHUD, "frame");
                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );        
                        CG_DrawPic( 
                                focusItem->window.rect.x, 
                                focusItem->window.rect.y, 
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background 
                                );                      
                }

                if (cg.predictedPlayerState.pm_type != PM_SPECTATOR)
                {
                        CG_DrawArmor(menuHUD);
                        CG_DrawHealth(menuHUD);
                }
        }
        else
        { 
                //CG_Error("CG_ChatBox_ArrayInsert: unable to locate HUD menu file ");
        }

        //scoreStr = va("Score: %i", cgs.clientinfo[cg.snap->ps.clientNum].score);
        if ( cgs.gametype == GT_DUEL )
        {//A duel that requires more than one kill to knock the current enemy back to the queue
                //show current kills out of how many needed
                scoreStr = va("%s: %i/%i", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE], cgs.fraglimit);
        }
        else if (0 && cgs.gametype < GT_TEAM )
        {       // This is a teamless mode, draw the score bias.
                scoreBias = cg.snap->ps.persistant[PERS_SCORE] - cgs.scores1;
                if (scoreBias == 0)
                {       // We are the leader!
                        if (cgs.scores2 <= 0)
                        {       // Nobody to be ahead of yet.
                                Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), "");
                        }
                        else
                        {
                                scoreBias = cg.snap->ps.persistant[PERS_SCORE] - cgs.scores2;
                                if (scoreBias == 0)
                                {
                                        Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (Tie)");
                                }
                                else
                                {
                                        Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (+%d)", scoreBias);
                                }
                        }
                }
                else // if (scoreBias < 0)
                {       // We are behind!
                        Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (%d)", scoreBias);
                }
                scoreStr = va("%s: %i%s", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE], scoreBiasStr);
        }
        else
        {       // Don't draw a bias.
                scoreStr = va("%s: %i", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE]);
        }

        menuHUD = Menus_FindByName("righthud");

        if (menuHUD)
        {
                if (cgs.gametype != GT_POWERDUEL)
                {
                        focusItem = Menu_FindItemByName(menuHUD, "score_line");
                        if (focusItem)
                        {
                                UI_DrawScaledProportionalString(
                                        focusItem->window.rect.x, 
                                        focusItem->window.rect.y, 
                                        scoreStr, 
                                        UI_RIGHT|UI_DROPSHADOW, 
                                        focusItem->window.foreColor, 
                                        0.7);
                        }
                }

                // Print scanline
                focusItem = Menu_FindItemByName(menuHUD, "scanline");
                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );        
                        CG_DrawPic( 
                                focusItem->window.rect.x, 
                                focusItem->window.rect.y, 
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background 
                                );                      
                }

                focusItem = Menu_FindItemByName(menuHUD, "frame");
                if (focusItem)
                {
                        trap_R_SetColor( hudTintColor );        
                        CG_DrawPic( 
                                focusItem->window.rect.x, 
                                focusItem->window.rect.y, 
                                focusItem->window.rect.w, 
                                focusItem->window.rect.h, 
                                focusItem->window.background 
                                );                      
                }

                CG_DrawForcePower(menuHUD);

                // Draw ammo tics or saber style
                if ( cent->currentState.weapon == WP_SABER )
                {
                        CG_DrawSaberStyle(cent,menuHUD);
                }
                else
                {
                        CG_DrawAmmo(cent,menuHUD);
                }
        }
        else
        { 
                //CG_Error("CG_ChatBox_ArrayInsert: unable to locate HUD menu file ");
        }
}

#define MAX_SHOWPOWERS NUM_FORCE_POWERS

qboolean ForcePower_Valid(int i)
{
        if (i == FP_LEVITATION ||
                i == FP_SABER_OFFENSE ||
                i == FP_SABER_DEFENSE ||
                i == FP_SABERTHROW)
        {
                return qfalse;
        }

        if (cg.snap->ps.fd.forcePowersKnown & (1 << i))
        {
                return qtrue;
        }
        
        return qfalse;
}

/*
===================
CG_DrawForceSelect
===================
*/
#ifdef _XBOX
extern bool CL_ExtendSelectTime(void);
#endif
void CG_DrawForceSelect( void ) 
{
        int             i;
        int             count;
        int             smallIconSize,bigIconSize;
        int             holdX,x,y,x2,y2,pad,length;
        int             sideLeftIconCnt,sideRightIconCnt;
        int             sideMax,holdCount,iconCnt;
        int             yOffset = 0;


        x2 = 0;
        y2 = 0;

        // don't display if dead
        if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
        {
                return;
        }

        if ((cg.forceSelectTime+WEAPON_SELECT_TIME)<cg.time)    // Time is up for the HUD to display
        {
                cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
                return;
        }

        if (!cg.snap->ps.fd.forcePowersKnown)
        {
                return;
        }

#ifdef _XBOX
        if(CL_ExtendSelectTime()) {
                cg.forceSelectTime = cg.time;
        }
        yOffset = -50;
#endif

        // count the number of powers owned
        count = 0;

        for (i=0;i < NUM_FORCE_POWERS;++i)
        {
                if (ForcePower_Valid(i))
                {
                        count++;
                }
        }

        if (count == 0) // If no force powers, don't display
        {
                return;
        }

        sideMax = 3;    // Max number of icons on the side

        // Calculate how many icons will appear to either side of the center one
        holdCount = count - 1;  // -1 for the center icon
        if (holdCount == 0)                     // No icons to either side
        {
                sideLeftIconCnt = 0;
                sideRightIconCnt = 0;
        }
        else if (count > (2*sideMax))   // Go to the max on each side
        {
                sideLeftIconCnt = sideMax;
                sideRightIconCnt = sideMax;
        }
        else                                                    // Less than max, so do the calc
        {
                sideLeftIconCnt = holdCount/2;
                sideRightIconCnt = holdCount - sideLeftIconCnt;
        }

        smallIconSize = 30;
        bigIconSize = 60;
        pad = 12;

        x = 320;
        y = 425;

        // Background
        length = (sideLeftIconCnt * smallIconSize) + (sideLeftIconCnt*pad) +
                        bigIconSize + (sideRightIconCnt * smallIconSize) + (sideRightIconCnt*pad) + 12;
        
        i = BG_ProperForceIndex(cg.forceSelect) - 1;
        if (i < 0)
        {
                i = MAX_SHOWPOWERS;
        }

        trap_R_SetColor(NULL);
        // Work backwards from current icon
        holdX = x - ((bigIconSize/2) + pad + smallIconSize);
        for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
        {
                if (i < 0)
                {
                        i = MAX_SHOWPOWERS;
                }

                if (!ForcePower_Valid(forcePowerSorted[i]))     // Does he have this power?
                {
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (cgs.media.forcePowerIcons[forcePowerSorted[i]])
                {
                        CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, cgs.media.forcePowerIcons[forcePowerSorted[i]] ); 
                        holdX -= (smallIconSize+pad);
                }
        }

        if (ForcePower_Valid(cg.forceSelect))
        {
                // Current Center Icon
                if (cgs.media.forcePowerIcons[cg.forceSelect])
                {
                        CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2)) + yOffset, bigIconSize, bigIconSize, cgs.media.forcePowerIcons[cg.forceSelect] ); //only cache the icon for display
                }
        }

        i = BG_ProperForceIndex(cg.forceSelect) + 1;
        if (i>MAX_SHOWPOWERS)
        {
                i = 0;
        }

        // Work forwards from current icon
        holdX = x + (bigIconSize/2) + pad;
        for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
        {
                if (i>MAX_SHOWPOWERS)
                {
                        i = 0;
                }

                if (!ForcePower_Valid(forcePowerSorted[i]))     // Does he have this power?
                {
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (cgs.media.forcePowerIcons[forcePowerSorted[i]])
                {
                        CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, cgs.media.forcePowerIcons[forcePowerSorted[i]] ); //only cache the icon for display
                        holdX += (smallIconSize+pad);
                }
        }

        if ( showPowersName[cg.forceSelect] ) 
        {
                UI_DrawProportionalString(320, y + 30 + yOffset, CG_GetStringEdString("SP_INGAME", showPowersName[cg.forceSelect]), UI_CENTER | UI_SMALLFONT, colorTable[CT_ICON_BLUE]);
        }
}

/*
===================
CG_DrawInventorySelect
===================
*/
void CG_DrawInvenSelect( void ) 
{
        int                             i;
        int                             sideMax,holdCount,iconCnt;
        int                             smallIconSize,bigIconSize;
        int                             sideLeftIconCnt,sideRightIconCnt;
        int                             count;
        int                             holdX,x,y,y2,pad;
        int                             height;
        float                   addX;

        // don't display if dead
        if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
        {
                return;
        }

        if ((cg.invenSelectTime+WEAPON_SELECT_TIME)<cg.time)    // Time is up for the HUD to display
        {
                return;
        }

        if (!cg.snap->ps.stats[STAT_HOLDABLE_ITEM] || !cg.snap->ps.stats[STAT_HOLDABLE_ITEMS])
        {
                return;
        }

#ifdef _XBOX
        if(CL_ExtendSelectTime()) {
                cg.invenSelectTime = cg.time;
        }
#endif

        if (cg.itemSelect == -1)
        {
                cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
        }

//const int bits = cg.snap->ps.stats[ STAT_ITEMS ];

        // count the number of items owned
        count = 0;
        for ( i = 0 ; i < HI_NUM_HOLDABLE ; i++ ) 
        {
                if (/*CG_InventorySelectable(i) && inv_icons[i]*/
                        (cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) ) 
                {
                        count++;
                }
        }

        if (!count)
        {
                y2 = 0; //err?
                UI_DrawProportionalString(320, y2 + 22, "EMPTY INVENTORY", UI_CENTER | UI_SMALLFONT, colorTable[CT_ICON_BLUE]);
                return;
        }

        sideMax = 3;    // Max number of icons on the side

        // Calculate how many icons will appear to either side of the center one
        holdCount = count - 1;  // -1 for the center icon
        if (holdCount == 0)                     // No icons to either side
        {
                sideLeftIconCnt = 0;
                sideRightIconCnt = 0;
        }
        else if (count > (2*sideMax))   // Go to the max on each side
        {
                sideLeftIconCnt = sideMax;
                sideRightIconCnt = sideMax;
        }
        else                                                    // Less than max, so do the calc
        {
                sideLeftIconCnt = holdCount/2;
                sideRightIconCnt = holdCount - sideLeftIconCnt;
        }

        i = cg.itemSelect - 1;
        if (i<0)
        {
                i = HI_NUM_HOLDABLE-1;
        }

        smallIconSize = 40;
        bigIconSize = 80;
        pad = 16;

        x = 320;
        y = 410;

        // Left side ICONS
        // Work backwards from current icon
        holdX = x - ((bigIconSize/2) + pad + smallIconSize);
        height = smallIconSize * cg.iconHUDPercent;
        addX = (float) smallIconSize * .75;

        for (iconCnt=0;iconCnt<sideLeftIconCnt;i--)
        {
                if (i<0)
                {
                        i = HI_NUM_HOLDABLE-1;
                }

                if ( !(cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) || i == cg.itemSelect )
                {
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (!BG_IsItemSelectable(&cg.predictedPlayerState, i))
                {
                        continue;
                }

                if (cgs.media.invenIcons[i])
                {
                        trap_R_SetColor(NULL);
                        CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, cgs.media.invenIcons[i] );

                        trap_R_SetColor(colorTable[CT_ICON_BLUE]);
                        /*CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
                                NUM_FONT_SMALL,qfalse);
                                */

                        holdX -= (smallIconSize+pad);
                }
        }

        // Current Center Icon
        height = bigIconSize * cg.iconHUDPercent;
        if (cgs.media.invenIcons[cg.itemSelect] && BG_IsItemSelectable(&cg.predictedPlayerState, cg.itemSelect))
        {
                int itemNdex;
                trap_R_SetColor(NULL);
                CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, cgs.media.invenIcons[cg.itemSelect] );
                addX = (float) bigIconSize * .75;
                trap_R_SetColor(colorTable[CT_ICON_BLUE]);
                /*CG_DrawNumField ((x-(bigIconSize/2)) + addX, y, 2, cg.snap->ps.inventory[cg.inventorySelect], 6, 12, 
                        NUM_FONT_SMALL,qfalse);*/

                itemNdex = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
                if (bg_itemlist[itemNdex].classname)
                {
                        vec4_t  textColor = { .312f, .75f, .621f, 1.0f };
                        char    text[1024];
                        char    upperKey[1024];

                        strcpy(upperKey, bg_itemlist[itemNdex].classname);
                        
                        if ( trap_SP_GetStringTextString( va("SP_INGAME_%s",Q_strupr(upperKey)), text, sizeof( text )))
                        {
                                UI_DrawProportionalString(320, y+45, text, UI_CENTER | UI_SMALLFONT, textColor);
                        }
                        else
                        {
                                UI_DrawProportionalString(320, y+45, bg_itemlist[itemNdex].classname, UI_CENTER | UI_SMALLFONT, textColor);
                        }
                }
        }

        i = cg.itemSelect + 1;
        if (i> HI_NUM_HOLDABLE-1)
        {
                i = 0;
        }

        // Right side ICONS
        // Work forwards from current icon
        holdX = x + (bigIconSize/2) + pad;
        height = smallIconSize * cg.iconHUDPercent;
        addX = (float) smallIconSize * .75;
        for (iconCnt=0;iconCnt<sideRightIconCnt;i++)
        {
                if (i> HI_NUM_HOLDABLE-1)
                {
                        i = 0;
                }

                if ( !(cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) || i == cg.itemSelect )
                {
                        continue;
                }

                ++iconCnt;                                      // Good icon

                if (!BG_IsItemSelectable(&cg.predictedPlayerState, i))
                {
                        continue;
                }

                if (cgs.media.invenIcons[i])
                {
                        trap_R_SetColor(NULL);
                        CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, cgs.media.invenIcons[i] );

                        trap_R_SetColor(colorTable[CT_ICON_BLUE]);
                        /*CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
                                NUM_FONT_SMALL,qfalse);*/

                        holdX += (smallIconSize+pad);
                }
        }
}

int cg_targVeh = ENTITYNUM_NONE;
int cg_targVehLastTime = 0;
qboolean CG_CheckTargetVehicle( centity_t **pTargetVeh, float *alpha )
{
        int targetNum = ENTITYNUM_NONE;
        centity_t       *targetVeh = NULL;
        
        if ( !pTargetVeh || !alpha )
        {//hey, where are my pointers?
                return qfalse;
        }

        *alpha = 1.0f;

        //FIXME: need to clear all of these when you die?
        if ( cg.predictedPlayerState.rocketLockIndex < ENTITYNUM_WORLD )
        {
                targetNum = cg.predictedPlayerState.rocketLockIndex;
        }
        else if ( cg.crosshairVehNum < ENTITYNUM_WORLD 
                && cg.time - cg.crosshairVehTime < 3000 )
        {//crosshair was on a vehicle in the last 3 seconds
                targetNum = cg.crosshairVehNum;
        }
    else if ( cg.crosshairClientNum < ENTITYNUM_WORLD )
        {
                targetNum = cg.crosshairClientNum;
        }

        if ( targetNum < MAX_CLIENTS )
        {//real client
                if ( cg_entities[targetNum].currentState.m_iVehicleNum >= MAX_CLIENTS )
                {//in a vehicle
                        targetNum = cg_entities[targetNum].currentState.m_iVehicleNum;
                }
        }
    if ( targetNum < ENTITYNUM_WORLD 
                && targetNum >= MAX_CLIENTS )
        {
                centity_t *targetVeh = &cg_entities[targetNum];
                if ( targetVeh->currentState.NPC_class == CLASS_VEHICLE 
                        && targetVeh->m_pVehicle
                        && targetVeh->m_pVehicle->m_pVehicleInfo
                        && targetVeh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
                {//it's a vehicle
                        cg_targVeh = targetNum;
                        cg_targVehLastTime = cg.time;
                        *alpha = 1.0f;
                }
                else
                {
                        targetVeh = NULL;
                }
        }
        if ( !targetVeh )
        {
                if ( cg_targVehLastTime && cg.time - cg_targVehLastTime < 3000 )
                {
                        targetVeh = &cg_entities[cg_targVeh];;
                        if ( cg.time-cg_targVehLastTime < 1000 )
                        {//stay at full alpha for 1 sec after lose them from crosshair
                                *alpha = 1.0f;
                        }
                        else
                        {//fade out over 2 secs
                                *alpha = 1.0f-((cg.time-cg_targVehLastTime-1000)/2000.0f);
                        }
                }
        }
        if ( targetVeh )
        {
                *pTargetVeh = targetVeh;
                return qtrue;
        }
        return qfalse;
}

#define MAX_VHUD_SHIELD_TICS 12
#define MAX_VHUD_SPEED_TICS 5
#define MAX_VHUD_ARMOR_TICS 5
#define MAX_VHUD_AMMO_TICS 5

float CG_DrawVehicleShields( const menuDef_t    *menuHUD, const centity_t *veh )
{
        int                             i;
        char                    itemName[64];
        float                   inc, currValue,maxShields;
        vec4_t                  calcColor;
        itemDef_t               *item;
        float                   percShields;

        item = Menu_FindItemByName((menuDef_t   *) menuHUD, "armorbackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        maxShields = veh->m_pVehicle->m_pVehicleInfo->shields;
        currValue = cg.predictedVehicleState.stats[STAT_ARMOR];
        percShields = (float)currValue/(float)maxShields;
        // Print all the tics of the shield graphic
        // Look at the amount of health left and show only as much of the graphic as there is health.
        // Use alpha to fade out partial section of health
        inc = (float) maxShields / MAX_VHUD_ARMOR_TICS;
        for (i=1;i<=MAX_VHUD_ARMOR_TICS;i++)
        {
                sprintf( itemName, "armor_tic%d",       i );

                item = Menu_FindItemByName((menuDef_t *) menuHUD, itemName);

                if (!item)
                {
                        continue;
                }

                memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));

                if (currValue <= 0)     // don't show tic
                {
                        break;
                }
                else if (currValue < inc)       // partial tic (alpha it out)
                {
                        float percent = currValue / inc;
                        calcColor[3] *= percent;                // Fade it out
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }

        return percShields;
}

int cg_vehicleAmmoWarning = 0;
int cg_vehicleAmmoWarningTime = 0;
void CG_DrawVehicleAmmo( const menuDef_t *menuHUD, const centity_t *veh )
{
        int i;
        char itemName[64];
        float inc, currValue,maxAmmo;
        vec4_t  calcColor;
        itemDef_t       *item;

        item = Menu_FindItemByName((menuDef_t *) menuHUD, "ammobackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[0].ammoMax;
        currValue = cg.predictedVehicleState.ammo[0];
        
        inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
        for (i=1;i<=MAX_VHUD_AMMO_TICS;i++)
        {
                sprintf( itemName, "ammo_tic%d",        i );

                item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);

                if (!item)
                {
                        continue;
                }

                if ( cg_vehicleAmmoWarningTime > cg.time 
                        && cg_vehicleAmmoWarning == 0 )
                {
                        memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
                        calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
                }
                else
                {
                        memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));

                        if (currValue <= 0)     // don't show tic
                        {
                                break;
                        }
                        else if (currValue < inc)       // partial tic (alpha it out)
                        {
                                float percent = currValue / inc;
                                calcColor[3] *= percent;                // Fade it out
                        }
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }
}


void CG_DrawVehicleAmmoUpper( const menuDef_t *menuHUD, const centity_t *veh )
{
        int                     i;
        char            itemName[64];
        float           inc, currValue,maxAmmo;
        vec4_t          calcColor;
        itemDef_t       *item;

        item = Menu_FindItemByName((menuDef_t *)menuHUD, "ammoupperbackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[0].ammoMax;
        currValue = cg.predictedVehicleState.ammo[0];

        inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
        for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
        {
                sprintf( itemName, "ammoupper_tic%d",   i );

                item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);

                if (!item)
                {
                        continue;
                }

                if ( cg_vehicleAmmoWarningTime > cg.time 
                        && cg_vehicleAmmoWarning == 0 )
                {
                        memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
                        calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
                }
                else
                {
                        memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));

                        if (currValue <= 0)     // don't show tic
                        {
                                break;
                        }
                        else if (currValue < inc)       // partial tic (alpha it out)
                        {
                                float percent = currValue / inc;
                                calcColor[3] *= percent;                // Fade it out
                        }
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }
}


void CG_DrawVehicleAmmoLower( const menuDef_t *menuHUD, const centity_t *veh )
{
        int                             i;
        char                    itemName[64];
        float                   inc, currValue,maxAmmo;
        vec4_t                  calcColor;
        itemDef_t               *item;


        item = Menu_FindItemByName((menuDef_t *)menuHUD, "ammolowerbackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[1].ammoMax;
        currValue = cg.predictedVehicleState.ammo[1];

        inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
        for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
        {
                sprintf( itemName, "ammolower_tic%d",   i );

                item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);

                if (!item)
                {
                        continue;
                }

                if ( cg_vehicleAmmoWarningTime > cg.time 
                        && cg_vehicleAmmoWarning == 1 )
                {
                        memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
                        calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
                }
                else
                {
                        memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));

                        if (currValue <= 0)     // don't show tic
                        {
                                break;
                        }
                        else if (currValue < inc)       // partial tic (alpha it out)
                        {
                                float percent = currValue / inc;
                                calcColor[3] *= percent;                // Fade it out
                        }
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }
}

// The HUD.menu file has the graphic print with a negative height, so it will print from the bottom up.
void CG_DrawVehicleTurboRecharge( const menuDef_t       *menuHUD, const centity_t *veh )
{
        itemDef_t       *item;
        int                     height;

        item = Menu_FindItemByName( (menuDef_t  *) menuHUD, "turborecharge");

        if (item)
        {
                float percent=0.0f;
                int diff = ( cg.time - veh->m_pVehicle->m_iTurboTime );

                height = item->window.rect.h;

                if (diff > veh->m_pVehicle->m_pVehicleInfo->turboRecharge)
                {
                        percent = 1.0f;
                        trap_R_SetColor( colorTable[CT_GREEN] );
                }
                else 
                {
                        percent = (float) diff / veh->m_pVehicle->m_pVehicleInfo->turboRecharge;
                        if (percent < 0.0f)
                        {
                                percent = 0.0f;
                        }
                        trap_R_SetColor( colorTable[CT_RED] );
                }

                height *= percent;

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        height, 
                        cgs.media.whiteShader); 
        }
}

qboolean cg_drawLink = qfalse;
void CG_DrawVehicleWeaponsLinked( const menuDef_t       *menuHUD, const centity_t *veh )
{
        qboolean drawLink = qfalse;
        if ( veh->m_pVehicle
                && veh->m_pVehicle->m_pVehicleInfo
                && (veh->m_pVehicle->m_pVehicleInfo->weapon[0].linkable == 2|| veh->m_pVehicle->m_pVehicleInfo->weapon[1].linkable == 2) )
        {//weapon is always linked
                drawLink = qtrue;
        }
        else
        {
//MP way:
                //must get sent over network
                if ( cg.predictedVehicleState.vehWeaponsLinked )
                {
                        drawLink = qtrue;
                }
//NOTE: below is SP way
/*
                //just cheat it
                if ( veh->gent->m_pVehicle->weaponStatus[0].linked
                        || veh->gent->m_pVehicle->weaponStatus[1].linked )
                {
                        drawLink = qtrue;
                }
*/
        }

        if ( cg_drawLink != drawLink )
        {//state changed, play sound
                cg_drawLink = drawLink;
                trap_S_StartSound (NULL, cg.predictedPlayerState.clientNum, CHAN_LOCAL, trap_S_RegisterSound( "sound/vehicles/common/linkweaps.wav" ) );
        }

        if ( drawLink )
        {
                itemDef_t       *item;

                item = Menu_FindItemByName( (menuDef_t  *) menuHUD, "weaponslinked");

                if (item)
                {
                        trap_R_SetColor( colorTable[CT_CYAN] );

                                CG_DrawPic( 
                                item->window.rect.x, 
                                item->window.rect.y, 
                                item->window.rect.w, 
                                item->window.rect.h, 
                                cgs.media.whiteShader); 
                }
        }
}

void CG_DrawVehicleSpeed( const menuDef_t       *menuHUD, const centity_t *veh )
{
        int i;
        char itemName[64];
        float inc, currValue,maxSpeed;
        vec4_t          calcColor;
        itemDef_t       *item;

        item = Menu_FindItemByName((menuDef_t *) menuHUD, "speedbackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        maxSpeed = veh->m_pVehicle->m_pVehicleInfo->speedMax;
        currValue = cg.predictedVehicleState.speed;


        // Print all the tics of the shield graphic
        // Look at the amount of health left and show only as much of the graphic as there is health.
        // Use alpha to fade out partial section of health
        inc = (float) maxSpeed / MAX_VHUD_SPEED_TICS;
        for (i=1;i<=MAX_VHUD_SPEED_TICS;i++)
        {
                sprintf( itemName, "speed_tic%d",       i );

                item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);

                if (!item)
                {
                        continue;
                }

                if ( cg.time > veh->m_pVehicle->m_iTurboTime )
                {
                        memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
                }
                else    // In turbo mode
                {
                        if (cg.VHUDFlashTime < cg.time) 
                        {
                                cg.VHUDFlashTime = cg.time + 200;
                                if (cg.VHUDTurboFlag)
                                {
                                        cg.VHUDTurboFlag = qfalse;
                                }
                                else
                                {
                                        cg.VHUDTurboFlag = qtrue;
                                }
                        }

                        if (cg.VHUDTurboFlag)
                        {
                                memcpy(calcColor, colorTable[CT_LTRED1], sizeof(vec4_t));
                        }
                        else
                        {
                                memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
                        }  
                }


                if (currValue <= 0)     // don't show tic
                {
                        break;
                }
                else if (currValue < inc)       // partial tic (alpha it out)
                {
                        float percent = currValue / inc;
                        calcColor[3] *= percent;                // Fade it out
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }
}

void CG_DrawVehicleArmor( const menuDef_t *menuHUD, const centity_t *veh )
{
        int                     i;
        vec4_t          calcColor;
        char            itemName[64];
        float           inc, currValue,maxArmor;
        itemDef_t       *item;

        maxArmor = veh->m_pVehicle->m_pVehicleInfo->armor;
        currValue = cg.predictedVehicleState.stats[STAT_HEALTH];

        item = Menu_FindItemByName( (menuDef_t  *) menuHUD, "shieldbackground");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }


        // Print all the tics of the shield graphic
        // Look at the amount of health left and show only as much of the graphic as there is health.
        // Use alpha to fade out partial section of health
        inc = (float) maxArmor / MAX_VHUD_SHIELD_TICS;
        for (i=1;i <= MAX_VHUD_SHIELD_TICS;i++)
        {
                sprintf( itemName, "shield_tic%d",      i );

                item = Menu_FindItemByName((menuDef_t   *) menuHUD, itemName);

                if (!item)
                {
                        continue;
                }


                memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));

                if (currValue <= 0)     // don't show tic
                {
                        break;
                }
                else if (currValue < inc)       // partial tic (alpha it out)
                {
                        float percent = currValue / inc;
                        calcColor[3] *= percent;                // Fade it out
                }

                trap_R_SetColor( calcColor);

                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );

                currValue -= inc;
        }
}

enum
{
        VEH_DAMAGE_FRONT=0,
        VEH_DAMAGE_BACK,
        VEH_DAMAGE_LEFT,
        VEH_DAMAGE_RIGHT,
};

typedef struct 
{
        char    *itemName;
        short   heavyDamage;
        short   lightDamage;
} veh_damage_t;

veh_damage_t vehDamageData[4] = 
{
"vehicle_front",SHIPSURF_DAMAGE_FRONT_HEAVY,SHIPSURF_DAMAGE_FRONT_LIGHT,
"vehicle_back",SHIPSURF_DAMAGE_BACK_HEAVY,SHIPSURF_DAMAGE_BACK_LIGHT,
"vehicle_left",SHIPSURF_DAMAGE_LEFT_HEAVY,SHIPSURF_DAMAGE_LEFT_LIGHT,
"vehicle_right",SHIPSURF_DAMAGE_RIGHT_HEAVY,SHIPSURF_DAMAGE_RIGHT_LIGHT,
};

// Draw health graphic for given part of vehicle
void CG_DrawVehicleDamage(const centity_t *veh,int brokenLimbs,const menuDef_t  *menuHUD,float alpha,int index)
{
        itemDef_t               *item;
        int                             colorI;
        vec4_t                  color;
        int                             graphicHandle=0;

        item = Menu_FindItemByName((menuDef_t *)menuHUD, vehDamageData[index].itemName);
        if (item)
        {
                if (brokenLimbs & (1<<vehDamageData[index].heavyDamage))
                {
                        colorI = CT_RED;
                        if (brokenLimbs & (1<<vehDamageData[index].lightDamage))
                        {
                                colorI = CT_DKGREY;
                        }
                }
                else if (brokenLimbs & (1<<vehDamageData[index].lightDamage))
                {
                        colorI = CT_YELLOW;
                }
                else
                {
                        colorI = CT_GREEN;
                }

                VectorCopy4 ( colorTable[colorI], color );
                color[3] = alpha;
                trap_R_SetColor( color );

                switch ( index )
                {
                        case VEH_DAMAGE_FRONT :
                                graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconFrontHandle;
                                break;
                        case VEH_DAMAGE_BACK :
                                graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconBackHandle;
                                break;
                        case VEH_DAMAGE_LEFT :
                                graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconLeftHandle;
                                break;
                        case VEH_DAMAGE_RIGHT :
                                graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconRightHandle;
                                break;
                }

                if (graphicHandle)
                {
                        CG_DrawPic( 
                                item->window.rect.x, 
                                item->window.rect.y, 
                                item->window.rect.w, 
                                item->window.rect.h, 
                                graphicHandle );
                }
        }
}


// Used on both damage indicators :  player vehicle and the vehicle the player is locked on 
void CG_DrawVehicleDamageHUD(const centity_t *veh,int brokenLimbs,float percShields,char *menuName, float alpha)
{
        menuDef_t               *menuHUD;
        itemDef_t               *item;
        vec4_t                  color;

        menuHUD = Menus_FindByName(menuName);

        if ( !menuHUD )
        {
                return;
        }

        item = Menu_FindItemByName(menuHUD, "background");
        if (item)
        {
                if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicBackgroundHandle)
                {
                        if ( veh->damageTime > cg.time )
                        {//ship shields currently taking damage
                                //NOTE: cent->damageAngle can be accessed to get the direction from the ship origin to the impact point (in 3-D space)
                                float perc = 1.0f - ((veh->damageTime - cg.time) / 2000.0f/*MIN_SHIELD_TIME*/);
                                if ( perc < 0.0f )
                                {
                                        perc = 0.0f;
                                }
                                else if ( perc > 1.0f )
                                {
                                        perc = 1.0f;
                                }
                                color[0] = item->window.foreColor[0];//flash red
                                color[1] = item->window.foreColor[1]*perc;//fade other colors back in over time
                                color[2] = item->window.foreColor[2]*perc;//fade other colors back in over time
                                color[3] = item->window.foreColor[3];//always normal alpha
                                trap_R_SetColor( color );
                        }
                        else
                        {
                                trap_R_SetColor( item->window.foreColor );
                        }

                        CG_DrawPic( 
                                item->window.rect.x, 
                                item->window.rect.y, 
                                item->window.rect.w, 
                                item->window.rect.h, 
                                veh->m_pVehicle->m_pVehicleInfo->dmgIndicBackgroundHandle );
                }
        }

        item = Menu_FindItemByName(menuHUD, "outer_frame");
        if (item)
        {
                if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicFrameHandle)
                {
                        trap_R_SetColor( item->window.foreColor );
                        CG_DrawPic( 
                                item->window.rect.x, 
                                item->window.rect.y, 
                                item->window.rect.w, 
                                item->window.rect.h, 
                                veh->m_pVehicle->m_pVehicleInfo->dmgIndicFrameHandle );
                }
        }

        item = Menu_FindItemByName(menuHUD, "shields");
        if (item)
        {
                if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicShieldHandle)
                {
                        VectorCopy4 ( colorTable[CT_HUD_GREEN], color );
                        color[3] = percShields;
                        trap_R_SetColor( color );
                        CG_DrawPic( 
                                item->window.rect.x, 
                                item->window.rect.y, 
                                item->window.rect.w, 
                                item->window.rect.h, 
                                veh->m_pVehicle->m_pVehicleInfo->dmgIndicShieldHandle );
                }
        }

        //TODO: if we check nextState.brokenLimbs & prevState.brokenLimbs, we can tell when a damage flag has been added and flash that part of the ship
        //FIXME: when ship explodes, either stop drawing ship or draw all parts black
        CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_FRONT);
        CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_BACK);
        CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_LEFT);
        CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_RIGHT);
}

qboolean CG_DrawVehicleHud( const centity_t *cent )
{
        itemDef_t               *item;
        menuDef_t               *menuHUD;
        playerState_t   *ps;
        centity_t               *veh;
        float                   shieldPerc,alpha;
        
        menuHUD = Menus_FindByName("swoopvehiclehud");
        if (!menuHUD)
        {
                return qtrue;   // Draw player HUD
        }

        ps = &cg.predictedPlayerState;

        if (!ps || !(ps->m_iVehicleNum))
        {
                return qtrue;   // Draw player HUD
        }
        veh = &cg_entities[ps->m_iVehicleNum];

        if ( !veh )
        {
                return qtrue;   // Draw player HUD
        }

        CG_DrawVehicleTurboRecharge( menuHUD, veh );
        CG_DrawVehicleWeaponsLinked( menuHUD, veh );

        item = Menu_FindItemByName(menuHUD, "leftframe");

        // Draw frame
        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }

        item = Menu_FindItemByName(menuHUD, "rightframe");

        if (item)
        {
                trap_R_SetColor( item->window.foreColor );
                CG_DrawPic( 
                        item->window.rect.x, 
                        item->window.rect.y, 
                        item->window.rect.w, 
                        item->window.rect.h, 
                        item->window.background );
        }


        CG_DrawVehicleArmor( menuHUD, veh );

        // Get animal hud for speed
//      if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
//      {
//              menuHUD = Menus_FindByName("tauntaunhud");
//      }
        

        CG_DrawVehicleSpeed( menuHUD, veh );

        // Revert to swoophud
//      if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
//      {
//              menuHUD = Menus_FindByName("swoopvehiclehud");
//      }

//      if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
//      {
                shieldPerc = CG_DrawVehicleShields( menuHUD, veh );
//      }

        if (veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID && !veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID)
        {
                CG_DrawVehicleAmmo( menuHUD, veh );
        }
        else if (veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID && veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID)
        {
                CG_DrawVehicleAmmoUpper( menuHUD, veh );
                CG_DrawVehicleAmmoLower( menuHUD, veh );
        }

        // If he's hidden, he must be in a vehicle
        if (veh->m_pVehicle->m_pVehicleInfo->hideRider)
        {
                CG_DrawVehicleDamageHUD(veh,cg.predictedVehicleState.brokenLimbs,shieldPerc,"vehicledamagehud",1.0f);

                // Has he targeted an enemy?
                if (CG_CheckTargetVehicle( &veh, &alpha ))
                {
                        CG_DrawVehicleDamageHUD(veh,veh->currentState.brokenLimbs,((float)veh->currentState.activeForcePass/10.0f),"enemyvehicledamagehud",alpha);
                }

                return qfalse;  // Don't draw player HUD
        }

        return qtrue;   // Draw player HUD

}

/*
================
CG_DrawStats

================
*/
static void CG_DrawStats( void ) 
{
        centity_t               *cent;
        playerState_t   *ps;
        qboolean                drawHUD = qtrue;
/*      playerState_t   *ps;
        vec3_t                  angles;
//      vec3_t          origin;

        if ( cg_drawStatus.integer == 0 ) {
                return;
        }
*/
        cent = &cg_entities[cg.snap->ps.clientNum];
/*      ps = &cg.snap->ps;

        VectorClear( angles );

        // Do start
        if (!cg.interfaceStartupDone)
        {
                CG_InterfaceStartup();
        }

        cgi_UI_MenuPaintAll();*/

        if ( cent )
        {
                ps = &cg.predictedPlayerState;

                if ( (ps->m_iVehicleNum ) )     // In a vehicle???
                {
                        drawHUD = CG_DrawVehicleHud( cent );
                }
        }

        if (drawHUD)
        {
                CG_DrawHUD(cent);
        }

        /*CG_DrawArmor(cent);
        CG_DrawHealth(cent);
        CG_DrawAmmo(cent);

        CG_DrawTalk(cent);*/
}

/*
===================
CG_DrawPickupItem
===================
*/
static void CG_DrawPickupItem( void ) {
        int             value;
        float   *fadeColor;

        value = cg.itemPickup;
        if ( value && cg_items[ value ].icon != -1 ) 
        {
                fadeColor = CG_FadeColor( cg.itemPickupTime, 3000 );
                if ( fadeColor ) 
                {
                        CG_RegisterItemVisuals( value );
                        trap_R_SetColor( fadeColor );
                        CG_DrawPic( 573, 320, ICON_SIZE, ICON_SIZE, cg_items[ value ].icon );
                        trap_R_SetColor( NULL );
                }
        }
}

/*
================
CG_DrawTeamBackground

================
*/
void CG_DrawTeamBackground( int x, int y, int w, int h, float alpha, int team )
{
        vec4_t          hcolor;

        hcolor[3] = alpha;
        if ( team == TEAM_RED ) {
                hcolor[0] = 1;
                hcolor[1] = .2f;
                hcolor[2] = .2f;
        } else if ( team == TEAM_BLUE ) {
                hcolor[0] = .2f;
                hcolor[1] = .2f;
                hcolor[2] = 1;
        } else {
                return;
        }
//      trap_R_SetColor( hcolor );

        CG_FillRect ( x, y, w, h, hcolor );
//      CG_DrawPic( x, y, w, h, cgs.media.teamStatusBar );
        trap_R_SetColor( NULL );
}


/*
===========================================================================================

  UPPER RIGHT CORNER

===========================================================================================
*/

/*
================
CG_DrawMiniScoreboard
================
*/
static float CG_DrawMiniScoreboard ( float y ) 
{
        char temp[MAX_QPATH];
        int xOffset = 0;

#ifdef _XBOX
        xOffset = -40;
#endif

        if ( !cg_drawScores.integer )
        {
                return y;
        }

        if (cgs.gametype == GT_SIEGE)
        { //don't bother with this in siege
                return y;
        }

        if ( cgs.gametype >= GT_TEAM )
        {
                strcpy ( temp, va("%s: ", CG_GetStringEdString("MP_INGAME", "RED")));
                Q_strcat ( temp, MAX_QPATH, cgs.scores1==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores1)) );
                Q_strcat ( temp, MAX_QPATH, va(" %s: ", CG_GetStringEdString("MP_INGAME", "BLUE")) );
                Q_strcat ( temp, MAX_QPATH, cgs.scores2==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores2)) );

                CG_Text_Paint( 630 - CG_Text_Width ( temp, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, temp, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM );
                y += 15;
        }
        else
        {
                /*
                strcpy ( temp, "1st: " );
                Q_strcat ( temp, MAX_QPATH, cgs.scores1==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores1)) );
                
                Q_strcat ( temp, MAX_QPATH, " 2nd: " );
                Q_strcat ( temp, MAX_QPATH, cgs.scores2==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores2)) );
                
                CG_Text_Paint( 630 - CG_Text_Width ( temp, 0.7f, FONT_SMALL ), y, 0.7f, colorWhite, temp, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM );
                y += 15;
                */
                //rww - no longer doing this. Since the attacker now shows who is first, we print the score there.
        }               
        

        return y;
}

/*
================
CG_DrawEnemyInfo
================
*/
static float CG_DrawEnemyInfo ( float y ) 
{
        float           size;
        int                     clientNum;
        const char      *title;
        clientInfo_t    *ci;
        int xOffset = 0;

        if (!cg.snap)
        {
                return y;
        }

#ifdef _XBOX
        xOffset = -40;
#endif

        if ( !cg_drawEnemyInfo.integer ) 
        {
                return y;
        }

        if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) 
        {
                return y;
        }
        
        if (cgs.gametype == GT_POWERDUEL)
        { //just get out of here then
                return y;
        }

        if ( cgs.gametype == GT_JEDIMASTER )
        {
                //title = "Jedi Master";
                title = CG_GetStringEdString("MP_INGAME", "MASTERY7");
                clientNum = cgs.jediMaster;

                if ( clientNum < 0 )
                {
                        //return y;
//                      title = "Get Saber!";
                        title = CG_GetStringEdString("MP_INGAME", "GET_SABER");


                        size = ICON_SIZE * 1.25;
                        y += 5;

                        CG_DrawPic( 640 - size - 12 + xOffset, y, size, size, cgs.media.weaponIcons[WP_SABER] );

                        y += size;

                        /*
                        CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 0.7f, FONT_MEDIUM ), y, 0.7f, colorWhite, ci->name, 0, 0, 0, FONT_MEDIUM );
                        y += 15;
                        */

                        CG_Text_Paint( 630 - CG_Text_Width ( title, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, title, 0, 0, 0, FONT_MEDIUM );

                        return y + BIGCHAR_HEIGHT + 2;
                }
        }
        else if ( cg.snap->ps.duelInProgress )
        {
//              title = "Dueling";
                title = CG_GetStringEdString("MP_INGAME", "DUELING");
                clientNum = cg.snap->ps.duelIndex;
        }
        else if ( cgs.gametype == GT_DUEL && cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR)
        {
                title = CG_GetStringEdString("MP_INGAME", "DUELING");
                if (cg.snap->ps.clientNum == cgs.duelist1)
                {
                        clientNum = cgs.duelist2; //if power duel, should actually draw both duelists 2 and 3 I guess
                }
                else if (cg.snap->ps.clientNum == cgs.duelist2)
                {
                        clientNum = cgs.duelist1;
                }
                else if (cg.snap->ps.clientNum == cgs.duelist3)
                {
                        clientNum = cgs.duelist1;
                }
                else
                {
                        return y;
                }
        }
        else
        {
                /*
                title = "Attacker";
                clientNum = cg.predictedPlayerState.persistant[PERS_ATTACKER];

                if ( clientNum < 0 || clientNum >= MAX_CLIENTS || clientNum == cg.snap->ps.clientNum ) 
                {
                        return y;
                }

                if ( cg.time - cg.attackerTime > ATTACKER_HEAD_TIME ) 
                {
                        cg.attackerTime = 0;
                        return y;
                }
                */
                //As of current, we don't want to draw the attacker. Instead, draw whoever is in first place.
                if (cgs.duelWinner < 0 || cgs.duelWinner >= MAX_CLIENTS)
                {
                        return y;
                }


                title = va("%s: %i",CG_GetStringEdString("MP_INGAME", "LEADER"), cgs.scores1);

                /*
                if (cgs.scores1 == 1)
                {
                        title = va("%i kill", cgs.scores1);
                }
                else
                {
                        title = va("%i kills", cgs.scores1);
                }
                */
                clientNum = cgs.duelWinner;
        }

        if ( clientNum >= MAX_CLIENTS || !(&cgs.clientinfo[ clientNum ]) )
        {
                return y;
        }

        ci = &cgs.clientinfo[ clientNum ];

        size = ICON_SIZE * 1.25;
        y += 5;

        if ( ci->modelIcon )
        {
                CG_DrawPic( 640 - size - 5 + xOffset, y, size, size, ci->modelIcon );
        }

        y += size;

//      CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, ci->name, 0, 0, 0, FONT_MEDIUM );
        CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 1.0f, FONT_SMALL2 ) + xOffset, y, 1.0f, colorWhite, ci->name, 0, 0, 0, FONT_SMALL2 );

        y += 15;
//      CG_Text_Paint( 630 - CG_Text_Width ( title, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, title, 0, 0, 0, FONT_MEDIUM );
        CG_Text_Paint( 630 - CG_Text_Width ( title, 1.0f, FONT_SMALL2 ) + xOffset, y, 1.0f, colorWhite, title, 0, 0, 0, FONT_SMALL2 );

        if ( (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) && cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR)
        {//also print their score
                char text[1024];
                y += 15;
                Com_sprintf(text, sizeof(text), "%i/%i", cgs.clientinfo[clientNum].score, cgs.fraglimit );
                CG_Text_Paint( 630 - CG_Text_Width ( text, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, text, 0, 0, 0, FONT_MEDIUM );
        }

// nmckenzie: DUEL_HEALTH - fixme - need checks and such here.  And this is coded to duelist 1 right now, which is wrongly.
        if ( cgs.showDuelHealths >= 2)
        {
                y += 15;
                if ( cgs.duelist1 == clientNum )
                {
                        CG_DrawDuelistHealth ( 640 - size - 5 + xOffset, y, 64, 8, 1 );
                }
                else if ( cgs.duelist2 == clientNum )
                {
                        CG_DrawDuelistHealth ( 640 - size - 5 + xOffset, y, 64, 8, 2 );
                }
        }

        return y + BIGCHAR_HEIGHT + 2;
}

/*
==================
CG_DrawSnapshot
==================
*/
static float CG_DrawSnapshot( float y ) {
        char            *s;
        int                     w;
        int                     xOffset = 0;

#ifdef _XBOX
        xOffset = -40;
#endif

        s = va( "time:%i snap:%i cmd:%i", cg.snap->serverTime, 
                cg.latestSnapshotNum, cgs.serverCommandSequence );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

        CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);

        return y + BIGCHAR_HEIGHT + 4;
}

/*
==================
CG_DrawFPS
==================
*/
#define FPS_FRAMES      16
static float CG_DrawFPS( float y ) {
        char            *s;
        int                     w;
        static unsigned short previousTimes[FPS_FRAMES];
        static unsigned short index;
        static int      previous, lastupdate;
        int             t, i, fps, total;
        unsigned short frameTime;
#ifdef _XBOX
        const int               xOffset = -40;
#else
        const int               xOffset = 0;
#endif


        // don't use serverTime, because that will be drifting to
        // correct for internet lag changes, timescales, timedemos, etc
        t = trap_Milliseconds();
        frameTime = t - previous;
        previous = t;
        if (t - lastupdate > 50)        //don't sample faster than this
        {
                lastupdate = t;
                previousTimes[index % FPS_FRAMES] = frameTime;
                index++;
        }
        // average multiple frames together to smooth changes out a bit
        total = 0;
        for ( i = 0 ; i < FPS_FRAMES ; i++ ) {
                total += previousTimes[i];
        }
        if ( !total ) {
                total = 1;
        }
        fps = 1000 * FPS_FRAMES / total;

        s = va( "%ifps", fps );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

        CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);

        return y + BIGCHAR_HEIGHT + 4;
}

// nmckenzie: DUEL_HEALTH
#define MAX_HEALTH_FOR_IFACE    100
void CG_DrawHealthBarRough (float x, float y, int width, int height, float ratio, const float *color1, const float *color2)
{
        float midpoint, remainder;
        float color3[4] = {1, 0, 0, .7f};

        midpoint = width * ratio - 1;
        remainder = width - midpoint;
        color3[0] = color1[0] * 0.5f;

        assert(!(height%4));//this won't line up otherwise.
        CG_DrawRect(x + 1,                      y + height/2-1,  midpoint,      1,         height/4+1,  color1);        // creme-y filling.
        CG_DrawRect(x + midpoint,       y + height/2-1,  remainder,     1,         height/4+1,  color3);        // used-up-ness.
        CG_DrawRect(x,                          y,                               width,         height, 1,                      color2);        // hard crispy shell
}

void CG_DrawDuelistHealth ( float x, float y, float w, float h, int duelist )
{
        float   duelHealthColor[4] = {1, 0, 0, 0.7f};
        float   healthSrc = 0.0f;
        float   ratio;

        if ( duelist == 1 )
        {
                healthSrc = cgs.duelist1health;
        }
        else if (duelist == 2 )
        {
                healthSrc = cgs.duelist2health;
        }

        ratio = healthSrc / MAX_HEALTH_FOR_IFACE;
        if ( ratio > 1.0f )
        {
                ratio = 1.0f;
        }
        if ( ratio < 0.0f )
        {
                ratio = 0.0f;
        }
        duelHealthColor[0] = (ratio * 0.2f) + 0.5f;

        CG_DrawHealthBarRough (x, y, w, h, ratio, duelHealthColor, colorTable[CT_WHITE]);       // new art for this?  I'm not crazy about how this looks.
}

/*
=====================
CG_DrawRadar
=====================
*/
//#define RADAR_RANGE                           2500
float   cg_radarRange = 2500.0f;

#define RADAR_RADIUS                    60
#define RADAR_X                                 (580 - RADAR_RADIUS)
//#define RADAR_Y                                       10 //dynamic based on passed Y val
#define RADAR_CHAT_DURATION             6000
static int radarLockSoundDebounceTime = 0;
static int impactSoundDebounceTime = 0;
#define RADAR_MISSILE_RANGE                                     3000.0f
#define RADAR_ASTEROID_RANGE                            10000.0f
#define RADAR_MIN_ASTEROID_SURF_WARN_DIST       1200.0f

float CG_DrawRadar ( float y )
{
        vec4_t                  color;
        vec4_t                  teamColor;
        float                   arrow_w;
        float                   arrow_h;
        clientInfo_t    *cl;
        clientInfo_t    *local;
        int                             i;
        float                   arrowBaseScale;
        float                   zScale;
        int                             xOffset = 0;

        if (!cg.snap)
        {
                return y;
        }

#ifdef _XBOX
        xOffset = -40;
#endif

        // Make sure the radar should be showing
        if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 )
        {
                return y;
        }

        if ( (cg.predictedPlayerState.pm_flags & PMF_FOLLOW) || cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_SPECTATOR )
        {
                return y;
        }

        local = &cgs.clientinfo[ cg.snap->ps.clientNum ];
        if ( !local->infoValid )
        {
                return y;
        }

        // Draw the radar background image
        color[0] = color[1] = color[2] = 1.0f;
        color[3] = 0.6f;
        trap_R_SetColor ( color );
        CG_DrawPic( RADAR_X + xOffset, y, RADAR_RADIUS*2, RADAR_RADIUS*2, cgs.media.radarShader );

        //Always green for your own team.
        VectorCopy ( g_color_table[ColorIndex(COLOR_GREEN)], teamColor );
        teamColor[3] = 1.0f;

        // Draw all of the radar entities.  Draw them backwards so players are drawn last
        for ( i = cg.radarEntityCount -1 ; i >= 0 ; i-- ) 
        {       
                vec3_t          dirLook;        
                vec3_t          dirPlayer;
                float           angleLook;
                float           anglePlayer;
                float           angle;
                float           distance, actualDist;
                centity_t*      cent;

                cent = &cg_entities[cg.radarEntities[i]];

                // Get the distances first
                VectorSubtract ( cg.predictedPlayerState.origin, cent->lerpOrigin, dirPlayer );         
                dirPlayer[2] = 0;
                actualDist = distance = VectorNormalize ( dirPlayer );

                if ( distance > cg_radarRange * 0.8f) 
                {
                        if ( (cent->currentState.eFlags & EF_RADAROBJECT)//still want to draw the direction
                                || ( cent->currentState.eType==ET_NPC//FIXME: draw last, with players...
                                        && cent->currentState.NPC_class == CLASS_VEHICLE 
                                        && cent->currentState.speed > 0 ) )//always draw vehicles
                        { 
                                distance = cg_radarRange*0.8f;
                        }
                        else
                        {
                                continue;
                        }
                }

                distance  = distance / cg_radarRange;
                distance *= RADAR_RADIUS;

                AngleVectors ( cg.predictedPlayerState.viewangles, dirLook, NULL, NULL );

                dirLook[2] = 0;
                anglePlayer = atan2(dirPlayer[0],dirPlayer[1]);         
                VectorNormalize ( dirLook );
                angleLook = atan2(dirLook[0],dirLook[1]);
                angle = angleLook - anglePlayer;

                switch ( cent->currentState.eType )
                {
                        default:
                                {
                                        float  x;
                                        float  ly;
                                        qhandle_t shader;
                                        vec4_t    color;

                                        x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
                                        ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;

                                        arrowBaseScale = 9.0f;
                                        shader = 0;
                                        zScale = 1.0f;

                                        //we want to scale the thing up/down based on the relative Z (up/down) positioning
                                        if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
                                        { //higher, scale up (between 16 and 24)
                                                float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
                                                
                                                //max out to 1.5x scale at 512 units above local player's height
                                                dif /= 1024.0f;
                                                if (dif > 0.5f)
                                                {
                                                        dif = 0.5f;
                                                }
                                                zScale += dif;
                                        }
                                        else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
                                        { //lower, scale down (between 16 and 8)
                                                float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);

                                                //half scale at 512 units below local player's height
                                                dif /= 1024.0f;
                                                if (dif > 0.5f)
                                                {
                                                        dif = 0.5f;
                                                }
                                                zScale -= dif;
                                        }

                                        arrowBaseScale *= zScale;

                                        if (cent->currentState.brokenLimbs)
                                        { //slightly misleading to use this value, but don't want to add more to entstate.
                                                //any ent with brokenLimbs non-0 and on radar is an objective ent.
                                                //brokenLimbs is literal team value.
                                                char objState[1024];
                                                int complete;

                                                //we only want to draw it if the objective for it is not complete.
                                                //frame represents objective num.
                                                trap_Cvar_VariableStringBuffer(va("team%i_objective%i", cent->currentState.brokenLimbs, cent->currentState.frame), objState, 1024);

                                                complete = atoi(objState);

                                                if (!complete)
                                                {
                                                
                                                        // generic enemy index specifies a shader to use for the radar entity.
                                                        if ( cent->currentState.genericenemyindex )
                                                        {
                                                                color[0] = color[1] = color[2] = color[3] = 1.0f;
                                                                shader = cgs.gameIcons[cent->currentState.genericenemyindex];
                                                        }
                                                        else
                                                        {
                                                                if (cg.snap &&
                                                                        cent->currentState.brokenLimbs == cg.snap->ps.persistant[PERS_TEAM])
                                                                {
                                                                        VectorCopy ( g_color_table[ColorIndex(COLOR_RED)], color );
                                                                }
                                                                else
                                                                {
                                                                        VectorCopy ( g_color_table[ColorIndex(COLOR_GREEN)], color );
                                                                }

                                                                shader = cgs.media.siegeItemShader;
                                                        }
                                                }
                                        }
                                        else
                                        {
                                                color[0] = color[1] = color[2] = color[3] = 1.0f;
                                                
                                                // generic enemy index specifies a shader to use for the radar entity.
                                                if ( cent->currentState.genericenemyindex )
                                                {
                                                        shader = cgs.gameIcons[cent->currentState.genericenemyindex];
                                                }
                                                else
                                                {
                                                        shader = cgs.media.siegeItemShader;
                                                }
                                        
                                        }

                                        if ( shader )
                                        {
                                                // Pulse the alpha if time2 is set.  time2 gets set when the entity takes pain
                                                if ( (cent->currentState.time2 && cg.time - cent->currentState.time2 < 5000) ||
                                                        (cent->currentState.time2 == 0xFFFFFFFF) )
                                                {                                                               
                                                        if ( (cg.time / 200) & 1 )
                                                        {
                                                                color[3] = 0.1f + 0.9f * (float) (cg.time % 200) / 200.0f;
                                                        }
                                                        else
                                                        {
                                                                color[3] = 1.0f - 0.9f * (float) (cg.time % 200) / 200.0f;
                                                        }                                       
                                                }

                                                trap_R_SetColor ( color );
                                                CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, shader );
                                        }
                                }
                                break;

                        case ET_NPC://FIXME: draw last, with players...
                                if ( cent->currentState.NPC_class == CLASS_VEHICLE 
                                        && cent->currentState.speed > 0 )
                                {
                                        if ( cent->m_pVehicle && cent->m_pVehicle->m_pVehicleInfo->radarIconHandle )
                                        {
                                                float  x;
                                                float  ly;
                        
                                                x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
                                                ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;

                                                arrowBaseScale = 9.0f;
                                                zScale = 1.0f;

                                                //we want to scale the thing up/down based on the relative Z (up/down) positioning
                                                if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
                                                { //higher, scale up (between 16 and 24)
                                                        float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
                                                        
                                                        //max out to 1.5x scale at 512 units above local player's height
                                                        dif /= 4096.0f;
                                                        if (dif > 0.5f)
                                                        {
                                                                dif = 0.5f;
                                                        }
                                                        zScale += dif;
                                                }
                                                else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
                                                { //lower, scale down (between 16 and 8)
                                                        float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);

                                                        //half scale at 512 units below local player's height
                                                        dif /= 4096.0f;
                                                        if (dif > 0.5f)
                                                        {
                                                                dif = 0.5f;
                                                        }
                                                        zScale -= dif;
                                                }

                                                arrowBaseScale *= zScale;

                                                if ( cent->currentState.m_iVehicleNum //vehicle has a driver
                                                        && cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].infoValid )
                                                {
                                                        if ( cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].team == local->team )
                                                        {
                                                                trap_R_SetColor ( teamColor );
                                                        }
                                                        else
                                                        {
                                                                trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
                                                        }
                                                }
                                                else
                                                {
                                                        trap_R_SetColor ( NULL );
                                                }
                                                CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, cent->m_pVehicle->m_pVehicleInfo->radarIconHandle );
                                        }
                                }
                                break; //maybe do something?

                        case ET_MOVER:
                                if ( cent->currentState.speed//the mover's size, actually
                                        && actualDist < (cent->currentState.speed+RADAR_ASTEROID_RANGE)
                                        && cg.predictedPlayerState.m_iVehicleNum )
                                {//a mover that's close to me and I'm in a vehicle
                                        qboolean mayImpact = qfalse;
                                        float surfaceDist = (actualDist-cent->currentState.speed);
                                        if ( surfaceDist < 0.0f )
                                        {
                                                surfaceDist = 0.0f;
                                        }
                                        if ( surfaceDist < RADAR_MIN_ASTEROID_SURF_WARN_DIST )
                                        {//always warn!
                                                mayImpact = qtrue;
                                        }
                                        else
                                        {//not close enough to always warn, yet, so check its direction
                                                vec3_t  asteroidPos, myPos, moveDir;
                                                int             predictTime, timeStep = 500;
                                                float   newDist;
                                                for ( predictTime = timeStep; predictTime < 5000; predictTime+=timeStep )
                                                {
                                                        //asteroid dir, speed, size, + my dir & speed...
                                                        BG_EvaluateTrajectory( &cent->currentState.pos, cg.time+predictTime, asteroidPos );
                                                        //FIXME: I don't think it's calcing "myPos" correctly
                                                        AngleVectors( cg.predictedVehicleState.viewangles, moveDir, NULL, NULL );
                                                        VectorMA( cg.predictedVehicleState.origin, cg.predictedVehicleState.speed*predictTime/1000.0f, moveDir, myPos );
                                                        newDist = Distance( myPos, asteroidPos );
                                                        if ( (newDist-cent->currentState.speed) <= RADAR_MIN_ASTEROID_SURF_WARN_DIST )//200.0f )
                                                        {//heading for an impact within the next 5 seconds
                                                                mayImpact = qtrue;
                                                                break;
                                                        }
                                                }
                                        }
                                        if ( mayImpact )
                                        {//possible collision
                                                vec4_t  asteroidColor = {0.5f,0.5f,0.5f,1.0f};
                                                float  x;
                                                float  ly;
                                                float asteroidScale = (cent->currentState.speed/2000.0f);//average asteroid radius?
                                                if ( actualDist > RADAR_ASTEROID_RANGE )
                                                {
                                                        actualDist = RADAR_ASTEROID_RANGE;
                                                }
                                                distance = (actualDist/RADAR_ASTEROID_RANGE)*RADAR_RADIUS;

                                                x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
                                                ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;
                                                
                                                if ( asteroidScale > 3.0f )
                                                {
                                                        asteroidScale = 3.0f;
                                                }
                                                else if ( asteroidScale < 0.2f )
                                                {
                                                        asteroidScale = 0.2f;
                                                }
                                                arrowBaseScale = (9.0f*asteroidScale);
                                                if ( impactSoundDebounceTime < cg.time )
                                                {
                                                        vec3_t  soundOrg;
                                                        if ( surfaceDist > RADAR_ASTEROID_RANGE*0.66f )
                                                        {
                                                                impactSoundDebounceTime = cg.time + 1000;
                                                        }
                                                        else if ( surfaceDist > RADAR_ASTEROID_RANGE/3.0f )
                                                        {
                                                                impactSoundDebounceTime = cg.time + 400;
                                                        }
                                                        else 
                                                        {
                                                                impactSoundDebounceTime = cg.time + 100;
                                                        }
                                                        VectorMA( cg.refdef.vieworg, -500.0f*(surfaceDist/RADAR_ASTEROID_RANGE), dirPlayer, soundOrg );
                                                        trap_S_StartSound( soundOrg, ENTITYNUM_WORLD, CHAN_AUTO, trap_S_RegisterSound( "sound/vehicles/common/impactalarm.wav" ) );
                                                }
                                                //brighten it the closer it is
                                                if ( surfaceDist > RADAR_ASTEROID_RANGE*0.66f )
                                                {
                                                        asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 0.7f;
                                                }
                                                else if ( surfaceDist > RADAR_ASTEROID_RANGE/3.0f )
                                                {
                                                        asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 0.85f;
                                                }
                                                else 
                                                {
                                                        asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 1.0f;
                                                }
                                                //alpha out the longer it's been since it was considered dangerous
                                                if ( (cg.time-impactSoundDebounceTime) > 100 )
                                                {
                                                        asteroidColor[3] = (float)((cg.time-impactSoundDebounceTime)-100)/900.0f;
                                                }

                                                trap_R_SetColor ( asteroidColor );
                                                CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, trap_R_RegisterShaderNoMip( "gfx/menus/radar/asteroid" ) );
                                        }
                                }
                                break;

                        case ET_MISSILE:
                                if ( //cent->currentState.weapon == WP_ROCKET_LAUNCHER &&//a rocket
                                        cent->currentState.owner > MAX_CLIENTS //belongs to an NPC
                                        && cg_entities[cent->currentState.owner].currentState.NPC_class == CLASS_VEHICLE )
                                {//a rocket belonging to an NPC, FIXME: only tracking rockets!
                                        float  x;
                                        float  ly;
                
                                        x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
                                        ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;

                                        arrowBaseScale = 3.0f;
                                        if ( cg.predictedPlayerState.m_iVehicleNum )
                                        {//I'm in a vehicle
                                                //if it's targetting me, then play an alarm sound if I'm in a vehicle
                                                if ( cent->currentState.otherEntityNum == cg.predictedPlayerState.clientNum || cent->currentState.otherEntityNum == cg.predictedPlayerState.m_iVehicleNum )
                                                {
                                                        if ( radarLockSoundDebounceTime < cg.time )
                                                        {
                                                                vec3_t  soundOrg;
                                                                int             alarmSound;
                                                                if ( actualDist > RADAR_MISSILE_RANGE * 0.66f )
                                                                {
                                                                        radarLockSoundDebounceTime = cg.time + 1000;
                                                                        arrowBaseScale = 3.0f;
                                                                        alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
                                                                }
                                                                else if ( actualDist > RADAR_MISSILE_RANGE/3.0f )
                                                                {
                                                                        radarLockSoundDebounceTime = cg.time + 500;
                                                                        arrowBaseScale = 6.0f;
                                                                        alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
                                                                }
                                                                else
                                                                {
                                                                        radarLockSoundDebounceTime = cg.time + 250;
                                                                        arrowBaseScale = 9.0f;
                                                                        alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
                                                                }
                                                                if ( actualDist > RADAR_MISSILE_RANGE )
                                                                {
                                                                        actualDist = RADAR_MISSILE_RANGE;
                                                                }
                                                                VectorMA( cg.refdef.vieworg, -500.0f*(actualDist/RADAR_MISSILE_RANGE), dirPlayer, soundOrg );
                                                                trap_S_StartSound( soundOrg, ENTITYNUM_WORLD, CHAN_AUTO, alarmSound );
                                                        }
                                                }
                                        }
                                        zScale = 1.0f;

                                        //we want to scale the thing up/down based on the relative Z (up/down) positioning
                                        if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
                                        { //higher, scale up (between 16 and 24)
                                                float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
                                                
                                                //max out to 1.5x scale at 512 units above local player's height
                                                dif /= 1024.0f;
                                                if (dif > 0.5f)
                                                {
                                                        dif = 0.5f;
                                                }
                                                zScale += dif;
                                        }
                                        else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
                                        { //lower, scale down (between 16 and 8)
                                                float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);

                                                //half scale at 512 units below local player's height
                                                dif /= 1024.0f;
                                                if (dif > 0.5f)
                                                {
                                                        dif = 0.5f;
                                                }
                                                zScale -= dif;
                                        }

                                        arrowBaseScale *= zScale;

                                        if ( cent->currentState.owner >= MAX_CLIENTS//missile owned by an NPC
                                                && cg_entities[cent->currentState.owner].currentState.NPC_class == CLASS_VEHICLE//NPC is a vehicle
                                                && cg_entities[cent->currentState.owner].currentState.m_iVehicleNum <= MAX_CLIENTS//Vehicle has a player driver
                                                && cgs.clientinfo[cg_entities[cent->currentState.owner].currentState.m_iVehicleNum-1].infoValid ) //player driver is valid
                                        {
                                                cl = &cgs.clientinfo[cg_entities[cent->currentState.owner].currentState.m_iVehicleNum-1];
                                                if ( cl->team == local->team )
                                                {
                                                        trap_R_SetColor ( teamColor );
                                                }
                                                else
                                                {
                                                        trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
                                                }
                                        }
                                        else
                                        {
                                                trap_R_SetColor ( NULL );
                                        }
                                        CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, cgs.media.mAutomapRocketIcon );
                                }
                                break;

                        case ET_PLAYER:
                        {
                                vec4_t color;

                                cl = &cgs.clientinfo[ cent->currentState.number ];

                                // not valid then dont draw it
                                if ( !cl->infoValid ) 
                                {       
                                        continue;
                                }

                                VectorCopy4 ( teamColor, color );

                                arrowBaseScale = 16.0f;
                                zScale = 1.0f;

                                // Pulse the radar icon after a voice message
                                if ( cent->vChatTime + 2000 > cg.time )
                                {
                                        float f = (cent->vChatTime + 2000 - cg.time) / 3000.0f;
                                        arrowBaseScale = 16.0f + 4.0f * f;
                                        color[0] = teamColor[0] + (1.0f - teamColor[0]) * f;
                                        color[1] = teamColor[1] + (1.0f - teamColor[1]) * f;
                                        color[2] = teamColor[2] + (1.0f - teamColor[2]) * f;
                                }

                                trap_R_SetColor ( color );

                                //we want to scale the thing up/down based on the relative Z (up/down) positioning
                                if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
                                { //higher, scale up (between 16 and 32)
                                        float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
                                        
                                        //max out to 2x scale at 1024 units above local player's height
                                        dif /= 1024.0f;
                                        if (dif > 1.0f)
                                        {
                                                dif = 1.0f;
                                        }
                                        zScale += dif;
                                }
                else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
                                { //lower, scale down (between 16 and 8)
                                        float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);

                                        //half scale at 512 units below local player's height
                                        dif /= 1024.0f;
                                        if (dif > 0.5f)
                                        {
                                                dif = 0.5f;
                                        }
                                        zScale -= dif;
                                }

                                arrowBaseScale *= zScale;

                                arrow_w = arrowBaseScale * RADAR_RADIUS / 128;
                                arrow_h = arrowBaseScale * RADAR_RADIUS / 128;

                                CG_DrawRotatePic2( RADAR_X + RADAR_RADIUS + sin (angle) * distance + xOffset,
                                                                   y + RADAR_RADIUS + cos (angle) * distance, 
                                                                   arrow_w, arrow_h, 
                                                                   (360 - cent->lerpAngles[YAW]) + cg.predictedPlayerState.viewangles[YAW], cgs.media.mAutomapPlayerIcon );
                                break;
                        }
                }
        }

        arrowBaseScale = 16.0f;

        arrow_w = arrowBaseScale * RADAR_RADIUS / 128;
        arrow_h = arrowBaseScale * RADAR_RADIUS / 128;

        trap_R_SetColor ( colorWhite );
        CG_DrawRotatePic2( RADAR_X + RADAR_RADIUS + xOffset, y + RADAR_RADIUS, arrow_w, arrow_h, 
                                           0, cgs.media.mAutomapPlayerIcon );

        return y+(RADAR_RADIUS*2);
}

/*
=================
CG_DrawTimer
=================
*/
static float CG_DrawTimer( float y ) {
        char            *s;
        int                     w;
        int                     mins, seconds, tens;
        int                     msec;
        int                     xOffset = 0;

#ifdef _XBOX
        xOffset = -40;
#endif

        msec = cg.time - cgs.levelStartTime;

        seconds = msec / 1000;
        mins = seconds / 60;
        seconds -= mins * 60;
        tens = seconds / 10;
        seconds -= tens * 10;

        s = va( "%i:%i%i", mins, tens, seconds );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

        CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);

        return y + BIGCHAR_HEIGHT + 4;
}


/*
=================
CG_DrawTeamOverlay
=================
*/
extern const char *CG_GetLocationString(const char *loc); //cg_main.c
static float CG_DrawTeamOverlay( float y, qboolean right, qboolean upper ) {
        int x, w, h, xx;
        int i, j, len;
        const char *p;
        vec4_t          hcolor;
        int pwidth, lwidth;
        int plyrs;
        char st[16];
        clientInfo_t *ci;
        gitem_t *item;
        int ret_y, count;
        int xOffset = 0;

#ifdef _XBOX
        xOffset = -40;
#endif

        if ( !cg_drawTeamOverlay.integer ) {
                return y;
        }

        if ( cg.snap->ps.persistant[PERS_TEAM] != TEAM_RED && cg.snap->ps.persistant[PERS_TEAM] != TEAM_BLUE ) {
                return y; // Not on any team
        }

        plyrs = 0;

        // max player name width
        pwidth = 0;
        count = (numSortedTeamPlayers > 8) ? 8 : numSortedTeamPlayers;
        for (i = 0; i < count; i++) {
                ci = cgs.clientinfo + sortedTeamPlayers[i];
                if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
                        plyrs++;
                        len = CG_DrawStrlen(ci->name);
                        if (len > pwidth)
                                pwidth = len;
                }
        }

        if (!plyrs)
                return y;

        if (pwidth > TEAM_OVERLAY_MAXNAME_WIDTH)
                pwidth = TEAM_OVERLAY_MAXNAME_WIDTH;

        // max location name width
        lwidth = 0;
        for (i = 1; i < MAX_LOCATIONS; i++) {
                p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+i));
                if (p && *p) {
                        len = CG_DrawStrlen(p);
                        if (len > lwidth)
                                lwidth = len;
                }
        }

        if (lwidth > TEAM_OVERLAY_MAXLOCATION_WIDTH)
                lwidth = TEAM_OVERLAY_MAXLOCATION_WIDTH;

        w = (pwidth + lwidth + 4 + 7) * TINYCHAR_WIDTH;

        if ( right )
                x = 640 - w;
        else
                x = 0;

        h = plyrs * TINYCHAR_HEIGHT;

        if ( upper ) {
                ret_y = y + h;
        } else {
                y -= h;
                ret_y = y;
        }

        if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
                hcolor[0] = 1.0f;
                hcolor[1] = 0.0f;
                hcolor[2] = 0.0f;
                hcolor[3] = 0.33f;
        } else { // if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE )
                hcolor[0] = 0.0f;
                hcolor[1] = 0.0f;
                hcolor[2] = 1.0f;
                hcolor[3] = 0.33f;
        }
        trap_R_SetColor( hcolor );
        CG_DrawPic( x + xOffset, y, w, h, cgs.media.teamStatusBar );
        trap_R_SetColor( NULL );

        for (i = 0; i < count; i++) {
                ci = cgs.clientinfo + sortedTeamPlayers[i];
                if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {

                        hcolor[0] = hcolor[1] = hcolor[2] = hcolor[3] = 1.0;

                        xx = x + TINYCHAR_WIDTH;

                        CG_DrawStringExt( xx + xOffset, y,
                                ci->name, hcolor, qfalse, qfalse,
                                TINYCHAR_WIDTH, TINYCHAR_HEIGHT, TEAM_OVERLAY_MAXNAME_WIDTH);

                        if (lwidth) {
                                p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+ci->location));
                                if (!p || !*p)
                                        p = "unknown";
                                len = CG_DrawStrlen(p);
                                if (len > lwidth)
                                        len = lwidth;

//                              xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth + 
//                                      ((lwidth/2 - len/2) * TINYCHAR_WIDTH);
                                xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth;
                                CG_DrawStringExt( xx + xOffset, y,
                                        p, hcolor, qfalse, qfalse, TINYCHAR_WIDTH, TINYCHAR_HEIGHT,
                                        TEAM_OVERLAY_MAXLOCATION_WIDTH);
                        }

                        CG_GetColorForHealth( ci->health, ci->armor, hcolor );

                        Com_sprintf (st, sizeof(st), "%3i %3i", ci->health,     ci->armor);

                        xx = x + TINYCHAR_WIDTH * 3 + 
                                TINYCHAR_WIDTH * pwidth + TINYCHAR_WIDTH * lwidth;

                        CG_DrawStringExt( xx + xOffset, y,
                                st, hcolor, qfalse, qfalse,
                                TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 0 );

                        // draw weapon icon
                        xx += TINYCHAR_WIDTH * 3;

                        if ( cg_weapons[ci->curWeapon].weaponIcon ) {
                                CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                                        cg_weapons[ci->curWeapon].weaponIcon );
                        } else {
                                CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                                        cgs.media.deferShader );
                        }

                        // Draw powerup icons
                        if (right) {
                                xx = x;
                        } else {
                                xx = x + w - TINYCHAR_WIDTH;
                        }
                        for (j = 0; j <= PW_NUM_POWERUPS; j++) {
                                if (ci->powerups & (1 << j)) {

                                        item = BG_FindItemForPowerup( j );

                                        if (item) {
                                                CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                                                trap_R_RegisterShader( item->icon ) );
                                                if (right) {
                                                        xx -= TINYCHAR_WIDTH;
                                                } else {
                                                        xx += TINYCHAR_WIDTH;
                                                }
                                        }
                                }
                        }

                        y += TINYCHAR_HEIGHT;
                }
        }

        return ret_y;
//#endif
}


static void CG_DrawPowerupIcons(int y)
{
        int j;
        int ico_size = 64;
        //int y = ico_size/2;
        int xOffset = 0;
        gitem_t *item;

#ifdef _XBOX
        xOffset = -40;
#endif

        if (!cg.snap)
        {
                return;
        }

        y += 16;

        for (j = 0; j <= PW_NUM_POWERUPS; j++)
        {
                if (cg.snap->ps.powerups[j] > cg.time)
                {
                        int secondsleft = (cg.snap->ps.powerups[j] - cg.time)/1000;

                        item = BG_FindItemForPowerup( j );

                        if (item)
                        {
                                int icoShader = 0;
                                if (cgs.gametype == GT_CTY && (j == PW_REDFLAG || j == PW_BLUEFLAG))
                                {
                                        if (j == PW_REDFLAG)
                                        {
                                                icoShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_ys" );
                                        }
                                        else
                                        {
                                                icoShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_ys" );
                                        }
                                }
                                else
                                {
                                        icoShader = trap_R_RegisterShader( item->icon );
                                }

                                CG_DrawPic( (640-(ico_size*1.1)) + xOffset, y, ico_size, ico_size, icoShader );
        
                                y += ico_size;

                                if (j != PW_REDFLAG && j != PW_BLUEFLAG && secondsleft < 999)
                                {
                                        UI_DrawProportionalString((640-(ico_size*1.1))+(ico_size/2) + xOffset, y-8, va("%i", secondsleft), UI_CENTER | UI_BIGFONT | UI_DROPSHADOW, colorTable[CT_WHITE]);
                                }

                                y += (ico_size/3);
                        }
                }
        }
}


/*
=====================
CG_DrawUpperRight

=====================
*/
static void CG_DrawUpperRight( void ) {
        float   y;

#ifdef _XBOX
        y = 50;
#else
        y = 0;
#endif

        trap_R_SetColor( colorTable[CT_WHITE] );

        if ( cgs.gametype >= GT_TEAM && cg_drawTeamOverlay.integer == 1 ) {
                y = CG_DrawTeamOverlay( y, qtrue, qtrue );
        } 
        if ( cg_drawSnapshot.integer ) {
                y = CG_DrawSnapshot( y );
        }

        if ( cg_drawFPS.integer ) {
                y = CG_DrawFPS( y );
        }
        if ( cg_drawTimer.integer ) {
                y = CG_DrawTimer( y );
        }

        if ( ( cgs.gametype >= GT_TEAM || cg.predictedPlayerState.m_iVehicleNum )
                && cg_drawRadar.integer )
        {//draw Radar in Siege mode or when in a vehicle of any kind
                y = CG_DrawRadar ( y );
        }

        y = CG_DrawEnemyInfo ( y );

        y = CG_DrawMiniScoreboard ( y );

        CG_DrawPowerupIcons(y);
}

/*
===================
CG_DrawReward
===================
*/
#ifdef JK2AWARDS
static void CG_DrawReward( void ) { 
        float   *color;
        int             i, count;
        float   x, y;
        char    buf[32];

        if ( !cg_drawRewards.integer ) {
                return;
        }

        color = CG_FadeColor( cg.rewardTime, REWARD_TIME );
        if ( !color ) {
                if (cg.rewardStack > 0) {
                        for(i = 0; i < cg.rewardStack; i++) {
                                cg.rewardSound[i] = cg.rewardSound[i+1];
                                cg.rewardShader[i] = cg.rewardShader[i+1];
                                cg.rewardCount[i] = cg.rewardCount[i+1];
                        }
                        cg.rewardTime = cg.time;
                        cg.rewardStack--;
                        color = CG_FadeColor( cg.rewardTime, REWARD_TIME );
                        trap_S_StartLocalSound(cg.rewardSound[0], CHAN_ANNOUNCER);
                } else {
                        return;
                }
        }

        trap_R_SetColor( color );

        /*
        count = cg.rewardCount[0]/10;                           // number of big rewards to draw

        if (count) {
                y = 4;
                x = 320 - count * ICON_SIZE;
                for ( i = 0 ; i < count ; i++ ) {
                        CG_DrawPic( x, y, (ICON_SIZE*2)-4, (ICON_SIZE*2)-4, cg.rewardShader[0] );
                        x += (ICON_SIZE*2);
                }
        }

        count = cg.rewardCount[0] - count*10;           // number of small rewards to draw
        */

        if ( cg.rewardCount[0] >= 10 ) {
                y = 56;
                x = 320 - ICON_SIZE/2;
                CG_DrawPic( x, y, ICON_SIZE-4, ICON_SIZE-4, cg.rewardShader[0] );
                Com_sprintf(buf, sizeof(buf), "%d", cg.rewardCount[0]);
                x = ( SCREEN_WIDTH - SMALLCHAR_WIDTH * CG_DrawStrlen( buf ) ) / 2;
                CG_DrawStringExt( x, y+ICON_SIZE, buf, color, qfalse, qtrue,
                                                                SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0 );
        }
        else {

                count = cg.rewardCount[0];

                y = 56;
                x = 320 - count * ICON_SIZE/2;
                for ( i = 0 ; i < count ; i++ ) {
                        CG_DrawPic( x, y, ICON_SIZE-4, ICON_SIZE-4, cg.rewardShader[0] );
                        x += ICON_SIZE;
                }
        }
        trap_R_SetColor( NULL );
}
#endif


/*
===============================================================================

LAGOMETER

===============================================================================
*/

#define LAG_SAMPLES             128


typedef struct {
        int             frameSamples[LAG_SAMPLES];
        int             frameCount;
        int             snapshotFlags[LAG_SAMPLES];
        int             snapshotSamples[LAG_SAMPLES];
        int             snapshotCount;
} lagometer_t;

lagometer_t             lagometer;

/*
==============
CG_AddLagometerFrameInfo

Adds the current interpolate / extrapolate bar for this frame
==============
*/
void CG_AddLagometerFrameInfo( void ) {
        int                     offset;

        offset = cg.time - cg.latestSnapshotTime;
        lagometer.frameSamples[ lagometer.frameCount & ( LAG_SAMPLES - 1) ] = offset;
        lagometer.frameCount++;
}

/*
==============
CG_AddLagometerSnapshotInfo

Each time a snapshot is received, log its ping time and
the number of snapshots that were dropped before it.

Pass NULL for a dropped packet.
==============
*/
void CG_AddLagometerSnapshotInfo( snapshot_t *snap ) {
        // dropped packet
        if ( !snap ) {
                lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = -1;
                lagometer.snapshotCount++;
                return;
        }

        // add this snapshot's info
        lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->ping;
        lagometer.snapshotFlags[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->snapFlags;
        lagometer.snapshotCount++;
}

/*
==============
CG_DrawDisconnect

Should we draw something differnet for long lag vs no packets?
==============
*/
static void CG_DrawDisconnect( void ) {
        float           x, y;
        int                     cmdNum;
        usercmd_t       cmd;
        const char              *s;
        int                     w;  // bk010215 - FIXME char message[1024];

        if (cg.mMapChange)
        {                       
                s = CG_GetStringEdString("MP_INGAME", "SERVER_CHANGING_MAPS");  // s = "Server Changing Maps";                  
                w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
                CG_DrawBigString( 320 - w/2, 100, s, 1.0F);

                s = CG_GetStringEdString("MP_INGAME", "PLEASE_WAIT");   // s = "Please wait...";
                w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
                CG_DrawBigString( 320 - w/2, 200, s, 1.0F);
                return;
        }

        // draw the phone jack if we are completely past our buffers
        cmdNum = trap_GetCurrentCmdNumber() - CMD_BACKUP + 1;
        trap_GetUserCmd( cmdNum, &cmd );
        if ( cmd.serverTime <= cg.snap->ps.commandTime
                || cmd.serverTime > cg.time ) { // special check for map_restart // bk 0102165 - FIXME
                return;
        }

        // also add text in center of screen
        s = CG_GetStringEdString("MP_INGAME", "CONNECTION_INTERRUPTED"); // s = "Connection Interrupted"; // bk 010215 - FIXME
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
        CG_DrawBigString( 320 - w/2, 100, s, 1.0F);

        // blink the icon
        if ( ( cg.time >> 9 ) & 1 ) {
                return;
        }

        x = 640 - 48;
        y = 480 - 48;

        CG_DrawPic( x, y, 48, 48, trap_R_RegisterShader("gfx/2d/net.tga" ) );
}


#define MAX_LAGOMETER_PING      900
#define MAX_LAGOMETER_RANGE     300

/*
==============
CG_DrawLagometer
==============
*/
static void CG_DrawLagometer( void ) {
        int             a, x, y, i;
        float   v;
        float   ax, ay, aw, ah, mid, range;
        int             color;
        float   vscale;

        if ( !cg_lagometer.integer || cgs.localServer ) {
                CG_DrawDisconnect();
                return;
        }

        //
        // draw the graph
        //
        x = 640 - 48;
        y = 480 - 144;

        trap_R_SetColor( NULL );
        CG_DrawPic( x, y, 48, 48, cgs.media.lagometerShader );

        ax = x;
        ay = y;
        aw = 48;
        ah = 48;

        color = -1;
        range = ah / 3;
        mid = ay + range;

        vscale = range / MAX_LAGOMETER_RANGE;

        // draw the frame interpoalte / extrapolate graph
        for ( a = 0 ; a < aw ; a++ ) {
                i = ( lagometer.frameCount - 1 - a ) & (LAG_SAMPLES - 1);
                v = lagometer.frameSamples[i];
                v *= vscale;
                if ( v > 0 ) {
                        if ( color != 1 ) {
                                color = 1;
                                trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
                        }
                        if ( v > range ) {
                                v = range;
                        }
                        trap_R_DrawStretchPic ( ax + aw - a, mid - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
                } else if ( v < 0 ) {
                        if ( color != 2 ) {
                                color = 2;
                                trap_R_SetColor( g_color_table[ColorIndex(COLOR_BLUE)] );
                        }
                        v = -v;
                        if ( v > range ) {
                                v = range;
                        }
                        trap_R_DrawStretchPic( ax + aw - a, mid, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
                }
        }

        // draw the snapshot latency / drop graph
        range = ah / 2;
        vscale = range / MAX_LAGOMETER_PING;

        for ( a = 0 ; a < aw ; a++ ) {
                i = ( lagometer.snapshotCount - 1 - a ) & (LAG_SAMPLES - 1);
                v = lagometer.snapshotSamples[i];
                if ( v > 0 ) {
                        if ( lagometer.snapshotFlags[i] & SNAPFLAG_RATE_DELAYED ) {
                                if ( color != 5 ) {
                                        color = 5;      // YELLOW for rate delay
                                        trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
                                }
                        } else {
                                if ( color != 3 ) {
                                        color = 3;
                                        trap_R_SetColor( g_color_table[ColorIndex(COLOR_GREEN)] );
                                }
                        }
                        v = v * vscale;
                        if ( v > range ) {
                                v = range;
                        }
                        trap_R_DrawStretchPic( ax + aw - a, ay + ah - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
                } else if ( v < 0 ) {
                        if ( color != 4 ) {
                                color = 4;              // RED for dropped snapshots
                                trap_R_SetColor( g_color_table[ColorIndex(COLOR_RED)] );
                        }
                        trap_R_DrawStretchPic( ax + aw - a, ay + ah - range, 1, range, 0, 0, 0, 0, cgs.media.whiteShader );
                }
        }

        trap_R_SetColor( NULL );

        if ( cg_nopredict.integer || cg_synchronousClients.integer ) {
                CG_DrawBigString( ax, ay, "snc", 1.0 );
        }

        CG_DrawDisconnect();
}

void CG_DrawSiegeMessage( const char *str, int objectiveScreen )
{
//      if (!( trap_Key_GetCatcher() & KEYCATCH_UI ))
        {
                trap_OpenUIMenu(UIMENU_CLOSEALL);
                trap_Cvar_Set("cg_siegeMessage", str);
                if (objectiveScreen)
                {
                        trap_OpenUIMenu(UIMENU_SIEGEOBJECTIVES);
                }
                else
                {
                        trap_OpenUIMenu(UIMENU_SIEGEMESSAGE);
                }
        }
}

void CG_DrawSiegeMessageNonMenu( const char *str )
{
        char    text[1024];
        if (str[0]=='@')
        {       
                trap_SP_GetStringTextString(str+1, text, sizeof(text));
                str = text;
        }
        CG_CenterPrint(str, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH);
}

/*
===============================================================================

CENTER PRINTING

===============================================================================
*/


/*
==============
CG_CenterPrint

Called for important messages that should stay in the center of the screen
for a few moments
==============
*/
void CG_CenterPrint( const char *str, int y, int charWidth ) {
        char    *s;

        Q_strncpyz( cg.centerPrint, str, sizeof(cg.centerPrint) );

        cg.centerPrintTime = cg.time;
        cg.centerPrintY = y;
        cg.centerPrintCharWidth = charWidth;

        // count the number of lines for centering
        cg.centerPrintLines = 1;
        s = cg.centerPrint;
        while( *s ) {
                if (*s == '\n')
                        cg.centerPrintLines++;
                s++;
        }
}


/*
===================
CG_DrawCenterString
===================
*/
static void CG_DrawCenterString( void ) {
        char    *start;
        int             l;
        int             x, y, w;
        int h;
        float   *color;
        const float scale = 1.0; //0.5

        if ( !cg.centerPrintTime ) {
                return;
        }

        color = CG_FadeColor( cg.centerPrintTime, 1000 * cg_centertime.value );
        if ( !color ) {
                return;
        }

        trap_R_SetColor( color );

        start = cg.centerPrint;

        y = cg.centerPrintY - cg.centerPrintLines * BIGCHAR_HEIGHT / 2;

        while ( 1 ) {
                char linebuffer[1024];

                for ( l = 0; l < 50; l++ ) {
                        if ( !start[l] || start[l] == '\n' ) {
                                break;
                        }
                        linebuffer[l] = start[l];
                }
                linebuffer[l] = 0;

                w = CG_Text_Width(linebuffer, scale, FONT_MEDIUM);
                h = CG_Text_Height(linebuffer, scale, FONT_MEDIUM);
                x = (SCREEN_WIDTH - w) / 2;
                CG_Text_Paint(x, y + h, scale, color, linebuffer, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
                y += h + 6;

                while ( *start && ( *start != '\n' ) ) {
                        start++;
                }
                if ( !*start ) {
                        break;
                }
                start++;
        }

        trap_R_SetColor( NULL );
}



/*
================================================================================

CROSSHAIR

================================================================================
*/

#define HEALTH_WIDTH            50.0f
#define HEALTH_HEIGHT           5.0f

//see if we can draw some extra info on this guy based on our class
void CG_DrawSiegeInfo(centity_t *cent, float chX, float chY, float chW, float chH)
{
        siegeExtended_t *se = &cg_siegeExtendedData[cent->currentState.number];
        clientInfo_t *ci;
        const char *configstring, *v;
        siegeClass_t *siegeClass;
        vec4_t aColor;
        vec4_t bColor;
        vec4_t cColor;
        float x;
        float y;
        float percent;
        int ammoMax;

        assert(cent->currentState.number < MAX_CLIENTS);

        if (se->lastUpdated > cg.time)
        { //strange, shouldn't happen
                return;
        }
        
        if ((cg.time - se->lastUpdated) > 10000)
        { //if you haven't received a status update on this guy in 10 seconds, forget about it
                return;
        }

        if (cent->currentState.eFlags & EF_DEAD)
        { //he's dead, don't display info on him
                return;
        }

        if (cent->currentState.weapon != se->weapon)
        { //data is invalidated until it syncs back again
                return;
        }

        ci = &cgs.clientinfo[cent->currentState.number];
        if (ci->team != cg.predictedPlayerState.persistant[PERS_TEAM])
        { //not on the same team
                return;
        }

        configstring = CG_ConfigString( cg.predictedPlayerState.clientNum + CS_PLAYERS );
        v = Info_ValueForKey( configstring, "siegeclass" );

        if (!v || !v[0])
        { //don't have siege class in info?
                return;
        }

        siegeClass = BG_SiegeFindClassByName(v);

        if (!siegeClass)
        { //invalid
                return;
        }

    if (!(siegeClass->classflags & (1<<CFL_STATVIEWER)))
        { //doesn't really have the ability to see others' stats
                return;
        }

        x = chX+((chW/2)-(HEALTH_WIDTH/2));
        y = (chY+chH) + 8.0f;
        percent = ((float)se->health/(float)se->maxhealth)*HEALTH_WIDTH;

        //color of the bar
        aColor[0] = 0.0f;
        aColor[1] = 1.0f;
        aColor[2] = 0.0f;
        aColor[3] = 0.4f;

        //color of the border
        bColor[0] = 0.0f;
        bColor[1] = 0.0f;
        bColor[2] = 0.0f;
        bColor[3] = 0.3f;

        //color of greyed out "missing health"
        cColor[0] = 0.5f;
        cColor[1] = 0.5f;
        cColor[2] = 0.5f;
        cColor[3] = 0.4f;

        //draw the background (black)
        CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);

        //now draw the part to show how much health there is in the color specified
        CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);

        //then draw the other part greyed out
        CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);


        //now draw his ammo
        ammoMax = ammoData[weaponData[cent->currentState.weapon].ammoIndex].max;
        if ( (cent->currentState.eFlags & EF_DOUBLE_AMMO) )
        {
                ammoMax *= 2;
        }

        x = chX+((chW/2)-(HEALTH_WIDTH/2));
        y = (chY+chH) + HEALTH_HEIGHT + 10.0f;

        if (!weaponData[cent->currentState.weapon].energyPerShot &&
                !weaponData[cent->currentState.weapon].altEnergyPerShot)
        { //a weapon that takes no ammo, so show full
                percent = HEALTH_WIDTH;
        }
        else
        {
                percent = ((float)se->ammo/(float)ammoMax)*HEALTH_WIDTH;
        }

        //color of the bar
        aColor[0] = 1.0f;
        aColor[1] = 1.0f;
        aColor[2] = 0.0f;
        aColor[3] = 0.4f;

        //color of the border
        bColor[0] = 0.0f;
        bColor[1] = 0.0f;
        bColor[2] = 0.0f;
        bColor[3] = 0.3f;

        //color of greyed out "missing health"
        cColor[0] = 0.5f;
        cColor[1] = 0.5f;
        cColor[2] = 0.5f;
        cColor[3] = 0.4f;

        //draw the background (black)
        CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);

        //now draw the part to show how much health there is in the color specified
        CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);

        //then draw the other part greyed out
        CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
}

//draw the health bar based on current "health" and maxhealth
void CG_DrawHealthBar(centity_t *cent, float chX, float chY, float chW, float chH)
{
        vec4_t aColor;
        vec4_t bColor;
        vec4_t cColor;
        float x = chX+((chW/2)-(HEALTH_WIDTH/2));
        float y = (chY+chH) + 8.0f;
        float percent = ((float)cent->currentState.health/(float)cent->currentState.maxhealth)*HEALTH_WIDTH;
        if (percent <= 0)
        {
                return;
        }

        //color of the bar
        if (!cent->currentState.teamowner || cgs.gametype < GT_TEAM)
        { //not owned by a team or teamplay
                aColor[0] = 1.0f;
                aColor[1] = 1.0f;
                aColor[2] = 0.0f;
                aColor[3] = 0.4f;
        }
        else if (cent->currentState.teamowner == cg.predictedPlayerState.persistant[PERS_TEAM])
        { //owned by my team
                aColor[0] = 0.0f;
                aColor[1] = 1.0f;
                aColor[2] = 0.0f;
                aColor[3] = 0.4f;
        }
        else
        { //hostile
                aColor[0] = 1.0f;
                aColor[1] = 0.0f;
                aColor[2] = 0.0f;
                aColor[3] = 0.4f;
        }

        //color of the border
        bColor[0] = 0.0f;
        bColor[1] = 0.0f;
        bColor[2] = 0.0f;
        bColor[3] = 0.3f;

        //color of greyed out "missing health"
        cColor[0] = 0.5f;
        cColor[1] = 0.5f;
        cColor[2] = 0.5f;
        cColor[3] = 0.4f;

        //draw the background (black)
        CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);

        //now draw the part to show how much health there is in the color specified
        CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);

        //then draw the other part greyed out
        CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
}

//same routine (at least for now), draw progress of a "hack" or whatever
void CG_DrawHaqrBar(float chX, float chY, float chW, float chH)
{
        vec4_t aColor;
        vec4_t bColor;
        vec4_t cColor;
        float x = chX+((chW/2)-(HEALTH_WIDTH/2));
        float y = (chY+chH) + 8.0f;
        float percent = (((float)cg.predictedPlayerState.hackingTime-(float)cg.time)/(float)cg.predictedPlayerState.hackingBaseTime)*HEALTH_WIDTH;

        if (percent > HEALTH_WIDTH ||
                percent < 1.0f)
        {
                return;
        }

        //color of the bar
        aColor[0] = 1.0f;
        aColor[1] = 1.0f;
        aColor[2] = 0.0f;
        aColor[3] = 0.4f;

        //color of the border
        bColor[0] = 0.0f;
        bColor[1] = 0.0f;
        bColor[2] = 0.0f;
        bColor[3] = 0.3f;

        //color of greyed out done area
        cColor[0] = 0.5f;
        cColor[1] = 0.5f;
        cColor[2] = 0.5f;
        cColor[3] = 0.1f;

        //draw the background (black)
        CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);

        //now draw the part to show how much health there is in the color specified
        CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);

        //then draw the other part greyed out
        CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);

        //draw the hacker icon
        CG_DrawPic(x, y-HEALTH_WIDTH, HEALTH_WIDTH, HEALTH_WIDTH, cgs.media.hackerIconShader);
}

//generic timing bar
int cg_genericTimerBar = 0;
int cg_genericTimerDur = 0;
vec4_t cg_genericTimerColor;
#define CGTIMERBAR_H                    50.0f
#define CGTIMERBAR_W                    10.0f
#define CGTIMERBAR_X                    (SCREEN_WIDTH-CGTIMERBAR_W-120.0f)
#define CGTIMERBAR_Y                    (SCREEN_HEIGHT-CGTIMERBAR_H-20.0f)
void CG_DrawGenericTimerBar(void)
{
        vec4_t aColor;
        vec4_t bColor;
        vec4_t cColor;
        float x = CGTIMERBAR_X;
        float y = CGTIMERBAR_Y;
        float percent = ((float)(cg_genericTimerBar-cg.time)/(float)cg_genericTimerDur)*CGTIMERBAR_H;

        if (percent > CGTIMERBAR_H)
        {
                return;
        }

        if (percent < 0.1f)
        {
                percent = 0.1f;
        }

        //color of the bar
        aColor[0] = cg_genericTimerColor[0];
        aColor[1] = cg_genericTimerColor[1];
        aColor[2] = cg_genericTimerColor[2];
        aColor[3] = cg_genericTimerColor[3];

        //color of the border
        bColor[0] = 0.0f;
        bColor[1] = 0.0f;
        bColor[2] = 0.0f;
        bColor[3] = 0.3f;

        //color of greyed out "missing fuel"
        cColor[0] = 0.5f;
        cColor[1] = 0.5f;
        cColor[2] = 0.5f;
        cColor[3] = 0.1f;

        //draw the background (black)
        CG_DrawRect(x, y, CGTIMERBAR_W, CGTIMERBAR_H, 1.0f, colorTable[CT_BLACK]);

        //now draw the part to show how much health there is in the color specified
        CG_FillRect(x+1.0f, y+1.0f+(CGTIMERBAR_H-percent), CGTIMERBAR_W-2.0f, CGTIMERBAR_H-1.0f-(CGTIMERBAR_H-percent), aColor);

        //then draw the other part greyed out
        CG_FillRect(x+1.0f, y+1.0f, CGTIMERBAR_W-2.0f, CGTIMERBAR_H-percent, cColor);
}

/*
=================
CG_DrawCrosshair
=================
*/

#ifdef _XBOX
int cg_crossHairStatus = 0;
#endif

float cg_crosshairPrevPosX = 0;
float cg_crosshairPrevPosY = 0;
#define CRAZY_CROSSHAIR_MAX_ERROR_X     (100.0f*640.0f/480.0f)
#define CRAZY_CROSSHAIR_MAX_ERROR_Y     (100.0f)
void CG_LerpCrosshairPos( float *x, float *y )
{
        if ( cg_crosshairPrevPosX )
        {//blend from old pos
                float maxMove = 30.0f * ((float)cg.frametime/500.0f) * 640.0f/480.0f;
                float xDiff = (*x - cg_crosshairPrevPosX);
                if ( fabs(xDiff) > CRAZY_CROSSHAIR_MAX_ERROR_X )
                {
                        maxMove = CRAZY_CROSSHAIR_MAX_ERROR_X;
                }
                if ( xDiff > maxMove )
                {
                        *x = cg_crosshairPrevPosX + maxMove;
                }
                else if ( xDiff < -maxMove )
                {
                        *x = cg_crosshairPrevPosX - maxMove;
                }
        }
        cg_crosshairPrevPosX = *x;

        if ( cg_crosshairPrevPosY )
        {//blend from old pos
                float maxMove = 30.0f * ((float)cg.frametime/500.0f);
                float yDiff = (*y - cg_crosshairPrevPosY);
                if ( fabs(yDiff) > CRAZY_CROSSHAIR_MAX_ERROR_Y )
                {
                        maxMove = CRAZY_CROSSHAIR_MAX_ERROR_X;
                }
                if ( yDiff > maxMove )
                {
                        *y = cg_crosshairPrevPosY + maxMove;
                }
                else if ( yDiff < -maxMove )
                {
                        *y = cg_crosshairPrevPosY - maxMove;
                }
        }
        cg_crosshairPrevPosY = *y;
}

vec3_t cg_crosshairPos={0,0,0};
static void CG_DrawCrosshair( vec3_t worldPoint, int chEntValid ) {
        float           w, h;
        qhandle_t       hShader = 0;
        float           f;
        float           x, y;
        qboolean        corona = qfalse;
        vec4_t          ecolor = {0,0,0,0};
        centity_t       *crossEnt = NULL;
        float           chX, chY;

#ifdef _XBOX
        cg_crossHairStatus = 0;
#endif

        if ( worldPoint )
        {
                VectorCopy( worldPoint, cg_crosshairPos );
        }

        if ( !cg_drawCrosshair.integer ) 
        {
                return;
        }

        if (cg.snap->ps.fallingToDeath)
        {
                return;
        }

        if ( cg.predictedPlayerState.zoomMode != 0 )
        {//not while scoped
                return;
        }

        if ( cg_crosshairHealth.integer )
        {
                vec4_t          hcolor;

                CG_ColorForHealth( hcolor );
                trap_R_SetColor( hcolor );
        }
        else
        {
                //set color based on what kind of ent is under crosshair
                if ( cg.crosshairClientNum >= ENTITYNUM_WORLD )
                {
                        trap_R_SetColor( NULL );
                }
                //rwwFIXMEFIXME: Write this a different way, it's getting a bit too sloppy looking
                else if (chEntValid &&
                        (cg_entities[cg.crosshairClientNum].currentState.number < MAX_CLIENTS ||
                        cg_entities[cg.crosshairClientNum].currentState.eType == ET_NPC ||
                        cg_entities[cg.crosshairClientNum].currentState.shouldtarget ||
                        cg_entities[cg.crosshairClientNum].currentState.health || //always show ents with health data under crosshair
                        (cg_entities[cg.crosshairClientNum].currentState.eType == ET_MOVER && cg_entities[cg.crosshairClientNum].currentState.bolt1 && cg.predictedPlayerState.weapon == WP_SABER) ||
                        (cg_entities[cg.crosshairClientNum].currentState.eType == ET_MOVER && cg_entities[cg.crosshairClientNum].currentState.teamowner)))
                {
                        crossEnt = &cg_entities[cg.crosshairClientNum];

                        if ( crossEnt->currentState.powerups & (1 <<PW_CLOAKED) )
                        { //don't show up for cloaked guys
                                ecolor[0] = 1.0;//R
                                ecolor[1] = 1.0;//G
                                ecolor[2] = 1.0;//B
                        }
                        else if ( crossEnt->currentState.number < MAX_CLIENTS )
                        {
                                if (cgs.gametype >= GT_TEAM &&
                                        cgs.clientinfo[crossEnt->currentState.number].team == cgs.clientinfo[cg.snap->ps.clientNum].team )
                                {
                                        //Allies are green
                                        ecolor[0] = 0.0;//R
                                        ecolor[1] = 1.0;//G
                                        ecolor[2] = 0.0;//B
                                }
                                else
                                {
                                        if (cgs.gametype == GT_POWERDUEL &&
                                                cgs.clientinfo[crossEnt->currentState.number].duelTeam == cgs.clientinfo[cg.snap->ps.clientNum].duelTeam)
                                        { //on the same duel team in powerduel, so he's a friend
                                                ecolor[0] = 0.0;//R
                                                ecolor[1] = 1.0;//G
                                                ecolor[2] = 0.0;//B
                                        }
                                        else
                                        { //Enemies are red
                                                ecolor[0] = 1.0;//R
                                                ecolor[1] = 0.0;//G
                                                ecolor[2] = 0.0;//B
#ifdef _XBOX
                                                cg_crossHairStatus = 1;
#endif
                                        }
                                }

                                if (cg.snap->ps.duelInProgress)
                                {
                                        if (crossEnt->currentState.number != cg.snap->ps.duelIndex)
                                        { //grey out crosshair for everyone but your foe if you're in a duel
                                                ecolor[0] = 0.4;
                                                ecolor[1] = 0.4;
                                                ecolor[2] = 0.4;
                                        }
                                }
                                else if (crossEnt->currentState.bolt1)
                                { //this fellow is in a duel. We just checked if we were in a duel above, so
                                  //this means we aren't and he is. Which of course means our crosshair greys out over him.
                                        ecolor[0] = 0.4;
                                        ecolor[1] = 0.4;
                                        ecolor[2] = 0.4;
                                }
                        }
                        else if (crossEnt->currentState.shouldtarget || crossEnt->currentState.eType == ET_NPC)
                        {
                                //VectorCopy( crossEnt->startRGBA, ecolor );
                                if ( !ecolor[0] && !ecolor[1] && !ecolor[2] )
                                {
                                        // We really don't want black, so set it to yellow
                                        ecolor[0] = 1.0F;//R
                                        ecolor[1] = 0.8F;//G
                                        ecolor[2] = 0.3F;//B
                                }

                                if (crossEnt->currentState.eType == ET_NPC)
                                {
                                        int plTeam;
                                        if (cgs.gametype == GT_SIEGE)
                                        {
                                                plTeam = cg.predictedPlayerState.persistant[PERS_TEAM];
                                        }
                                        else
                                        {
                                                plTeam = NPCTEAM_PLAYER;
                                        }

                                        if ( crossEnt->currentState.powerups & (1 <<PW_CLOAKED) )
                                        {
                                                ecolor[0] = 1.0;//R
                                                ecolor[1] = 1.0;//G
                                                ecolor[2] = 1.0;//B
                                        }
                                        else if ( !crossEnt->currentState.teamowner )
                                        { //not on a team
                                                if (!crossEnt->currentState.teamowner ||
                                                        crossEnt->currentState.NPC_class == CLASS_VEHICLE)
                                                { //neutral
                                                        if (crossEnt->currentState.owner < MAX_CLIENTS)
                                                        { //base color on who is pilotting this thing
                                                                clientInfo_t *ci = &cgs.clientinfo[crossEnt->currentState.owner];

                                                                if (cgs.gametype >= GT_TEAM && ci->team == cg.predictedPlayerState.persistant[PERS_TEAM])
                                                                { //friendly
                                                                        ecolor[0] = 0.0;//R
                                                                        ecolor[1] = 1.0;//G
                                                                        ecolor[2] = 0.0;//B
                                                                }
                                                                else
                                                                { //hostile
                                                                        ecolor[0] = 1.0;//R
                                                                        ecolor[1] = 0.0;//G
                                                                        ecolor[2] = 0.0;//B
#ifdef _XBOX
                                                                        cg_crossHairStatus = 1;
#endif
                                                                }
                                                        }
                                                        else
                                                        { //unmanned
                                                                ecolor[0] = 1.0;//R
                                                                ecolor[1] = 1.0;//G
                                                                ecolor[2] = 0.0;//B
                                                        }
                                                }
                                                else
                                                {
                                                        ecolor[0] = 1.0;//R
                                                        ecolor[1] = 0.0;//G
                                                        ecolor[2] = 0.0;//B
#ifdef _XBOX
                                                        cg_crossHairStatus = 1;
#endif
                                                }
                                        }
                                        else if ( crossEnt->currentState.teamowner != plTeam )
                                        {// on enemy team
                                                ecolor[0] = 1.0;//R
                                                ecolor[1] = 0.0;//G
                                                ecolor[2] = 0.0;//B
#ifdef _XBOX
                                                cg_crossHairStatus = 1;
#endif
                                        }
                                        else
                                        { //a friend
                                                ecolor[0] = 0.0;//R
                                                ecolor[1] = 1.0;//G
                                                ecolor[2] = 0.0;//B
                                        }
                                }
                                else if ( crossEnt->currentState.teamowner == TEAM_RED
                                        || crossEnt->currentState.teamowner == TEAM_BLUE )
                                {
                                        if (cgs.gametype < GT_TEAM)
                                        { //not teamplay, just neutral then
                                                ecolor[0] = 1.0;//R
                                                ecolor[1] = 1.0;//G
                                                ecolor[2] = 0.0;//B
                                        }
                                        else if ( crossEnt->currentState.teamowner != cgs.clientinfo[cg.snap->ps.clientNum].team )
                                        { //on the enemy team
                                                ecolor[0] = 1.0;//R
                                                ecolor[1] = 0.0;//G
                                                ecolor[2] = 0.0;//B
#ifdef _XBOX
                                                cg_crossHairStatus = 1;
#endif
                                        }
                                        else
                                        { //on my team
                                                ecolor[0] = 0.0;//R
                                                ecolor[1] = 1.0;//G
                                                ecolor[2] = 0.0;//B
                                        }
                                }
                                else if (crossEnt->currentState.owner == cg.snap->ps.clientNum ||
                                        (cgs.gametype >= GT_TEAM && crossEnt->currentState.teamowner == cgs.clientinfo[cg.snap->ps.clientNum].team))
                                {
                                        ecolor[0] = 0.0;//R
                                        ecolor[1] = 1.0;//G
                                        ecolor[2] = 0.0;//B
                                }
                                else if (crossEnt->currentState.teamowner == 16 ||
                                        (cgs.gametype >= GT_TEAM && crossEnt->currentState.teamowner && crossEnt->currentState.teamowner != cgs.clientinfo[cg.snap->ps.clientNum].team))
                                {
                                        ecolor[0] = 1.0;//R
                                        ecolor[1] = 0.0;//G
                                        ecolor[2] = 0.0;//B
#ifdef _XBOX
                                        cg_crossHairStatus = 1;
#endif
                                }
                        }
                        else if (crossEnt->currentState.eType == ET_MOVER && crossEnt->currentState.bolt1 && cg.predictedPlayerState.weapon == WP_SABER)
                        { //can push/pull this mover. Only show it if we're using the saber.
                                ecolor[0] = 0.2f;
                                ecolor[1] = 0.5f;
                                ecolor[2] = 1.0f;

                                corona = qtrue;
                        }
                        else if (crossEnt->currentState.eType == ET_MOVER && crossEnt->currentState.teamowner)
                        { //a team owns this - if it's my team green, if not red, if not teamplay then yellow
                                if (cgs.gametype < GT_TEAM)
                                {
                                        ecolor[0] = 1.0;//R
                                        ecolor[1] = 1.0;//G
                                        ecolor[2] = 0.0;//B
                                }
                else if (cg.predictedPlayerState.persistant[PERS_TEAM] != crossEnt->currentState.teamowner)
                                { //not my team
                                        ecolor[0] = 1.0;//R
                                        ecolor[1] = 0.0;//G
                                        ecolor[2] = 0.0;//B
#ifdef _XBOX
                                        cg_crossHairStatus = 1;
#endif
                                }
                                else
                                { //my team
                                        ecolor[0] = 0.0;//R
                                        ecolor[1] = 1.0;//G
                                        ecolor[2] = 0.0;//B
                                }
                        }
                        else if (crossEnt->currentState.health)
                        {
                                if (!crossEnt->currentState.teamowner || cgs.gametype < GT_TEAM)
                                { //not owned by a team or teamplay
                                        ecolor[0] = 1.0f;
                                        ecolor[1] = 1.0f;
                                        ecolor[2] = 0.0f;
                                }
                                else if (crossEnt->currentState.teamowner == cg.predictedPlayerState.persistant[PERS_TEAM])
                                { //owned by my team
                                        ecolor[0] = 0.0f;
                                        ecolor[1] = 1.0f;
                                        ecolor[2] = 0.0f;
                                }
                                else
                                { //hostile
                                        ecolor[0] = 1.0f;
                                        ecolor[1] = 0.0f;
                                        ecolor[2] = 0.0f;
#ifdef _XBOX
                                        cg_crossHairStatus = 1;
#endif
                                }
                        }

                        ecolor[3] = 1.0;

                        trap_R_SetColor( ecolor );
                }
        }

        if ( cg.predictedPlayerState.m_iVehicleNum )
        {//I'm in a vehicle
                centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
            if ( vehCent 
                        && vehCent->m_pVehicle 
                        && vehCent->m_pVehicle->m_pVehicleInfo 
                        && vehCent->m_pVehicle->m_pVehicleInfo->crosshairShaderHandle )
                {
                        hShader = vehCent->m_pVehicle->m_pVehicleInfo->crosshairShaderHandle;
                }
                //bigger by default
                w = cg_crosshairSize.value*2.0f;
                h = w;
        }
        else
        {
                w = h = cg_crosshairSize.value;
        }

        // pulse the size of the crosshair when picking up items
        f = cg.time - cg.itemPickupBlendTime;
        if ( f > 0 && f < ITEM_BLOB_TIME ) {
                f /= ITEM_BLOB_TIME;
                w *= ( 1 + f );
                h *= ( 1 + f );
        }

        if ( worldPoint && VectorLength( worldPoint ) )
        {
                if ( !CG_WorldCoordToScreenCoordFloat( worldPoint, &x, &y ) )
                {//off screen, don't draw it
                        return;
                }
                //CG_LerpCrosshairPos( &x, &y );
                x -= 320;
                y -= 240;
        }
        else
        {
                x = cg_crosshairX.integer;
                y = cg_crosshairY.integer;
        }

        if ( !hShader )
        {
                hShader = cgs.media.crosshairShader[ cg_drawCrosshair.integer % NUM_CROSSHAIRS ];
        }

        chX = x + cg.refdef.x + 0.5 * (640 - w);
        chY = y + cg.refdef.y + 0.5 * (480 - h);
        trap_R_DrawStretchPic( chX, chY, w, h, 0, 0, 1, 1, hShader );

        //draw a health bar directly under the crosshair if we're looking at something
        //that takes damage
        if (crossEnt &&
                crossEnt->currentState.maxhealth)
        {
                CG_DrawHealthBar(crossEnt, chX, chY, w, h);
                chY += HEALTH_HEIGHT*2;
        }
        else if (crossEnt && crossEnt->currentState.number < MAX_CLIENTS)
        {
                if (cgs.gametype == GT_SIEGE)
                {
                        CG_DrawSiegeInfo(crossEnt, chX, chY, w, h);
                        chY += HEALTH_HEIGHT*4;
                }
                if (cg.crosshairVehNum && cg.time == cg.crosshairVehTime)
                { //it was in the crosshair this frame
                        centity_t *hisVeh = &cg_entities[cg.crosshairVehNum];

                        if (hisVeh->currentState.eType == ET_NPC &&
                                hisVeh->currentState.NPC_class == CLASS_VEHICLE &&
                                hisVeh->currentState.maxhealth &&
                                hisVeh->m_pVehicle)
                        { //draw the health for this vehicle
                                CG_DrawHealthBar(hisVeh, chX, chY, w, h);
                                chY += HEALTH_HEIGHT*2;
                        }
                }
        }

        if (cg.predictedPlayerState.hackingTime)
        { //hacking something
                CG_DrawHaqrBar(chX, chY, w, h);
        }

        if (cg_genericTimerBar > cg.time)
        { //draw generic timing bar, can be used for whatever
                CG_DrawGenericTimerBar();
        }

        if ( corona ) // drawing extra bits
        {
                ecolor[3] = 0.5f;
                ecolor[0] = ecolor[1] = ecolor[2] = (1 - ecolor[3]) * ( sin( cg.time * 0.001f ) * 0.08f + 0.35f ); // don't draw full color
                ecolor[3] = 1.0f;

                trap_R_SetColor( ecolor );

                w *= 2.0f;
                h *= 2.0f;

                trap_R_DrawStretchPic( x + cg.refdef.x + 0.5 * (640 - w), 
                        y + cg.refdef.y + 0.5 * (480 - h), 
                        w, h, 0, 0, 1, 1, cgs.media.forceCoronaShader );
        }
}

qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
{
        float   xcenter, ycenter;
        vec3_t  local, transformed;
        vec3_t  vfwd;
        vec3_t  vright;
        vec3_t  vup;
        float xzi;
        float yzi;

//      xcenter = cg.refdef.width / 2;//gives screen coords adjusted for resolution
//      ycenter = cg.refdef.height / 2;//gives screen coords adjusted for resolution
        
        //NOTE: did it this way because most draw functions expect virtual 640x480 coords
        //      and adjust them for current resolution
        xcenter = 640.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn
        ycenter = 480.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn

        AngleVectors (cg.refdef.viewangles, vfwd, vright, vup);

        VectorSubtract (worldCoord, cg.refdef.vieworg, local);

        transformed[0] = DotProduct(local,vright);
        transformed[1] = DotProduct(local,vup);
        transformed[2] = DotProduct(local,vfwd);                

        // Make sure Z is not negative.
        if(transformed[2] < 0.01f)
        {
                return qfalse;
        }

        xzi = xcenter / transformed[2] * (96.0f/cg.refdef.fov_x);
        yzi = ycenter / transformed[2] * (102.0f/cg.refdef.fov_y);

        *x = xcenter + xzi * transformed[0];
        *y = ycenter - yzi * transformed[1];

        return qtrue;
}

qboolean CG_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
{
        float   xF, yF;
        qboolean retVal = CG_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
        *x = (int)xF;
        *y = (int)yF;
        return retVal;
}

/*
====================
CG_SaberClashFlare
====================
*/
int cg_saberFlashTime = 0;
vec3_t cg_saberFlashPos = {0, 0, 0};
void CG_SaberClashFlare( void ) 
{
        int                             t, maxTime = 150;
        vec3_t dif;
        vec3_t color;
        int x,y;
        float v, len;
        trace_t tr;

        t = cg.time - cg_saberFlashTime;

        if ( t <= 0 || t >= maxTime ) 
        {
                return;
        }

        // Don't do clashes for things that are behind us
        VectorSubtract( cg_saberFlashPos, cg.refdef.vieworg, dif );

        if ( DotProduct( dif, cg.refdef.viewaxis[0] ) < 0.2 )
        {
                return;
        }

        CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, cg_saberFlashPos, -1, CONTENTS_SOLID );

        if ( tr.fraction < 1.0f )
        {
                return;
        }

        len = VectorNormalize( dif );

        // clamp to a known range
        /*
        if ( len > 800 )
        {
                len = 800;
        }
        */
        if ( len > 1200 )
        {
                return;
        }

        v = ( 1.0f - ((float)t / maxTime )) * ((1.0f - ( len / 800.0f )) * 2.0f + 0.35f);
        if (v < 0.001f)
        {
                v = 0.001f;
        }

        CG_WorldCoordToScreenCo