codemp/game/g_client.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
#include "g_local.h"
#include "../ghoul2/G2.h"
#include "bg_saga.h"

// g_client.c -- client functions that don't happen every frame

static vec3_t   playerMins = {-15, -15, DEFAULT_MINS_2};
static vec3_t   playerMaxs = {15, 15, DEFAULT_MAXS_2};

extern int g_siegeRespawnCheck;

void WP_SaberAddG2Model( gentity_t *saberent, const char *saberModel, qhandle_t saberSkin );
void WP_SaberRemoveG2Model( gentity_t *saberent );
extern qboolean WP_SaberStyleValidForSaber( saberInfo_t *saber1, saberInfo_t *saber2, int saberHolstered, int saberAnimLevel );
extern qboolean WP_UseFirstValidSaberStyle( saberInfo_t *saber1, saberInfo_t *saber2, int saberHolstered, int *saberAnimLevel );

forcedata_t Client_Force[MAX_CLIENTS];

/*QUAKED info_player_duel (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for duelists in duel.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_duel( gentity_t *ent )
{
        int             i;

        G_SpawnInt( "nobots", "0", &i);
        if ( i ) {
                ent->flags |= FL_NO_BOTS;
        }
        G_SpawnInt( "nohumans", "0", &i );
        if ( i ) {
                ent->flags |= FL_NO_HUMANS;
        }
}

/*QUAKED info_player_duel1 (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for lone duelists in powerduel.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_duel1( gentity_t *ent )
{
        int             i;

        G_SpawnInt( "nobots", "0", &i);
        if ( i ) {
                ent->flags |= FL_NO_BOTS;
        }
        G_SpawnInt( "nohumans", "0", &i );
        if ( i ) {
                ent->flags |= FL_NO_HUMANS;
        }
}

/*QUAKED info_player_duel2 (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for paired duelists in powerduel.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_duel2( gentity_t *ent )
{
        int             i;

        G_SpawnInt( "nobots", "0", &i);
        if ( i ) {
                ent->flags |= FL_NO_BOTS;
        }
        G_SpawnInt( "nohumans", "0", &i );
        if ( i ) {
                ent->flags |= FL_NO_HUMANS;
        }
}

/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32) initial
potential spawning position for deathmatch games.
The first time a player enters the game, they will be at an 'initial' spot.
Targets will be fired when someone spawns in on them.
"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_deathmatch( gentity_t *ent ) {
        int             i;

        G_SpawnInt( "nobots", "0", &i);
        if ( i ) {
                ent->flags |= FL_NO_BOTS;
        }
        G_SpawnInt( "nohumans", "0", &i );
        if ( i ) {
                ent->flags |= FL_NO_HUMANS;
        }
}

/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 32)
Targets will be fired when someone spawns in on them.
equivelant to info_player_deathmatch
*/
void SP_info_player_start(gentity_t *ent) {
        ent->classname = "info_player_deathmatch";
        SP_info_player_deathmatch( ent );
}

/*QUAKED info_player_start_red (1 0 0) (-16 -16 -24) (16 16 32) INITIAL
For Red Team DM starts

Targets will be fired when someone spawns in on them.
equivalent to info_player_deathmatch

INITIAL - The first time a player enters the game, they will be at an 'initial' spot.

"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_start_red(gentity_t *ent) {
        SP_info_player_deathmatch( ent );
}

/*QUAKED info_player_start_blue (1 0 0) (-16 -16 -24) (16 16 32) INITIAL
For Blue Team DM starts

Targets will be fired when someone spawns in on them.
equivalent to info_player_deathmatch

INITIAL - The first time a player enters the game, they will be at an 'initial' spot.

"nobots" will prevent bots from using this spot.
"nohumans" will prevent non-bots from using this spot.
*/
void SP_info_player_start_blue(gentity_t *ent) {
        SP_info_player_deathmatch( ent );
}

void SiegePointUse( gentity_t *self, gentity_t *other, gentity_t *activator )
{
        //Toggle the point on/off
        if (self->genericValue1)
        {
                self->genericValue1 = 0;
        }
        else
        {
                self->genericValue1 = 1;
        }
}

/*QUAKED info_player_siegeteam1 (1 0 0) (-16 -16 -24) (16 16 32)
siege start point - team1
name and behavior of team1 depends on what is defined in the
.siege file for this level

startoff - if non-0 spawn point will be disabled until used
idealclass - if specified, this spawn point will be considered
"ideal" for players of this class name. Corresponds to the name
entry in the .scl (siege class) file.
Targets will be fired when someone spawns in on them.
*/
void SP_info_player_siegeteam1(gentity_t *ent) {
        int soff = 0;

        if (g_gametype.integer != GT_SIEGE)
        { //turn into a DM spawn if not in siege game mode
                ent->classname = "info_player_deathmatch";
                SP_info_player_deathmatch( ent );

                return;
        }

        G_SpawnInt("startoff", "0", &soff);

        if (soff)
        { //start disabled
                ent->genericValue1 = 0;
        }
        else
        {
                ent->genericValue1 = 1;
        }

        ent->use = SiegePointUse;
}

/*QUAKED info_player_siegeteam2 (0 0 1) (-16 -16 -24) (16 16 32)
siege start point - team2
name and behavior of team2 depends on what is defined in the
.siege file for this level

startoff - if non-0 spawn point will be disabled until used
idealclass - if specified, this spawn point will be considered
"ideal" for players of this class name. Corresponds to the name
entry in the .scl (siege class) file.
Targets will be fired when someone spawns in on them.
*/
void SP_info_player_siegeteam2(gentity_t *ent) {
        int soff = 0;

        if (g_gametype.integer != GT_SIEGE)
        { //turn into a DM spawn if not in siege game mode
                ent->classname = "info_player_deathmatch";
                SP_info_player_deathmatch( ent );

                return;
        }

        G_SpawnInt("startoff", "0", &soff);

        if (soff)
        { //start disabled
                ent->genericValue1 = 0;
        }
        else
        {
                ent->genericValue1 = 1;
        }

        ent->use = SiegePointUse;
}

/*QUAKED info_player_intermission (1 0 1) (-16 -16 -24) (16 16 32) RED BLUE
The intermission will be viewed from this point.  Target an info_notnull for the view direction.
RED - In a Siege game, the intermission will happen here if the Red (attacking) team wins
BLUE - In a Siege game, the intermission will happen here if the Blue (defending) team wins
*/
void SP_info_player_intermission( gentity_t *ent ) {

}

/*QUAKED info_player_intermission_red (1 0 1) (-16 -16 -24) (16 16 32)
The intermission will be viewed from this point.  Target an info_notnull for the view direction.

In a Siege game, the intermission will happen here if the Red (attacking) team wins
target - ent to look at
target2 - ents to use when this intermission point is chosen
*/
void SP_info_player_intermission_red( gentity_t *ent ) {

}

/*QUAKED info_player_intermission_blue (1 0 1) (-16 -16 -24) (16 16 32)
The intermission will be viewed from this point.  Target an info_notnull for the view direction.

In a Siege game, the intermission will happen here if the Blue (defending) team wins
target - ent to look at
target2 - ents to use when this intermission point is chosen
*/
void SP_info_player_intermission_blue( gentity_t *ent ) {

}

#define JMSABER_RESPAWN_TIME 20000 //in case it gets stuck somewhere no one can reach

void ThrowSaberToAttacker(gentity_t *self, gentity_t *attacker)
{
        gentity_t *ent = &g_entities[self->client->ps.saberIndex];
        vec3_t a;
        int altVelocity = 0;

        if (!ent || ent->enemy != self)
        { //something has gone very wrong (this should never happen)
                //but in case it does.. find the saber manually
#ifdef _DEBUG
                Com_Printf("Lost the saber! Attempting to use global pointer..\n");
#endif
                ent = gJMSaberEnt;

                if (!ent)
                {
#ifdef _DEBUG
                        Com_Printf("The global pointer was NULL. This is a bad thing.\n");
#endif
                        return;
                }

#ifdef _DEBUG
                Com_Printf("Got it (%i). Setting enemy to client %i.\n", ent->s.number, self->s.number);
#endif

                ent->enemy = self;
                self->client->ps.saberIndex = ent->s.number;
        }

        trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, "-1" );

        if (attacker && attacker->client && self->client->ps.saberInFlight)
        { //someone killed us and we had the saber thrown, so actually move this saber to the saber location
          //if we killed ourselves with saber thrown, however, same suicide rules of respawning at spawn spot still
          //apply.
                gentity_t *flyingsaber = &g_entities[self->client->ps.saberEntityNum];

                if (flyingsaber && flyingsaber->inuse)
                {
                        VectorCopy(flyingsaber->s.pos.trBase, ent->s.pos.trBase);
                        VectorCopy(flyingsaber->s.pos.trDelta, ent->s.pos.trDelta);
                        VectorCopy(flyingsaber->s.apos.trBase, ent->s.apos.trBase);
                        VectorCopy(flyingsaber->s.apos.trDelta, ent->s.apos.trDelta);

                        VectorCopy(flyingsaber->r.currentOrigin, ent->r.currentOrigin);
                        VectorCopy(flyingsaber->r.currentAngles, ent->r.currentAngles);
                        altVelocity = 1;
                }
        }

        self->client->ps.saberInFlight = qtrue; //say he threw it anyway in order to properly remove from dead body

        WP_SaberAddG2Model( ent, self->client->saber[0].model, self->client->saber[0].skin );

        ent->s.eFlags &= ~(EF_NODRAW);
        ent->s.modelGhoul2 = 1;
        ent->s.eType = ET_MISSILE;
        ent->enemy = NULL;

        if (!attacker || !attacker->client)
        {
                VectorCopy(ent->s.origin2, ent->s.pos.trBase);
                VectorCopy(ent->s.origin2, ent->s.origin);
                VectorCopy(ent->s.origin2, ent->r.currentOrigin);
                ent->pos2[0] = 0;
                trap_LinkEntity(ent);
                return;
        }

        if (!altVelocity)
        {
                VectorCopy(self->s.pos.trBase, ent->s.pos.trBase);
                VectorCopy(self->s.pos.trBase, ent->s.origin);
                VectorCopy(self->s.pos.trBase, ent->r.currentOrigin);

                VectorSubtract(attacker->client->ps.origin, ent->s.pos.trBase, a);

                VectorNormalize(a);

                ent->s.pos.trDelta[0] = a[0]*256;
                ent->s.pos.trDelta[1] = a[1]*256;
                ent->s.pos.trDelta[2] = 256;
        }

        trap_LinkEntity(ent);
}

void JMSaberThink(gentity_t *ent)
{
        gJMSaberEnt = ent;

        if (ent->enemy)
        {
                if (!ent->enemy->client || !ent->enemy->inuse)
                { //disconnected?
                        VectorCopy(ent->enemy->s.pos.trBase, ent->s.pos.trBase);
                        VectorCopy(ent->enemy->s.pos.trBase, ent->s.origin);
                        VectorCopy(ent->enemy->s.pos.trBase, ent->r.currentOrigin);
                        ent->s.modelindex = G_ModelIndex("models/weapons2/saber/saber_w.glm");
                        ent->s.eFlags &= ~(EF_NODRAW);
                        ent->s.modelGhoul2 = 1;
                        ent->s.eType = ET_MISSILE;
                        ent->enemy = NULL;

                        ent->pos2[0] = 1;
                        ent->pos2[1] = 0; //respawn next think
                        trap_LinkEntity(ent);
                }
                else
                {
                        ent->pos2[1] = level.time + JMSABER_RESPAWN_TIME;
                }
        }
        else if (ent->pos2[0] && ent->pos2[1] < level.time)
        {
                VectorCopy(ent->s.origin2, ent->s.pos.trBase);
                VectorCopy(ent->s.origin2, ent->s.origin);
                VectorCopy(ent->s.origin2, ent->r.currentOrigin);
                ent->pos2[0] = 0;
                trap_LinkEntity(ent);
        }

        ent->nextthink = level.time + 50;
        G_RunObject(ent);
}

void JMSaberTouch(gentity_t *self, gentity_t *other, trace_t *trace)
{
        int i = 0;
//      gentity_t *te;

        if (!other || !other->client || other->health < 1)
        {
                return;
        }

        if (self->enemy)
        {
                return;
        }

        if (!self->s.modelindex)
        {
                return;
        }

        if (other->client->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
        {
                return;
        }

        if (other->client->ps.isJediMaster)
        {
                return;
        }

        self->enemy = other;
        other->client->ps.stats[STAT_WEAPONS] = (1 << WP_SABER);
        other->client->ps.weapon = WP_SABER;
        other->s.weapon = WP_SABER;
        G_AddEvent(other, EV_BECOME_JEDIMASTER, 0);

        // Track the jedi master 
        trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, va("%i", other->s.number ) );

        if (g_spawnInvulnerability.integer)
        {
                other->client->ps.eFlags |= EF_INVULNERABLE;
                other->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
        }

        trap_SendServerCommand( -1, va("cp \"%s %s\n\"", other->client->pers.netname, G_GetStringEdString("MP_SVGAME", "BECOMEJM")) );

        other->client->ps.isJediMaster = qtrue;
        other->client->ps.saberIndex = self->s.number;

        if (other->health < 200 && other->health > 0)
        { //full health when you become the Jedi Master
                other->client->ps.stats[STAT_HEALTH] = other->health = 200;
        }

        if (other->client->ps.fd.forcePower < 100)
        {
                other->client->ps.fd.forcePower = 100;
        }

        while (i < NUM_FORCE_POWERS)
        {
                other->client->ps.fd.forcePowersKnown |= (1 << i);
                other->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_3;

                i++;
        }

        self->pos2[0] = 1;
        self->pos2[1] = level.time + JMSABER_RESPAWN_TIME;

        self->s.modelindex = 0;
        self->s.eFlags |= EF_NODRAW;
        self->s.modelGhoul2 = 0;
        self->s.eType = ET_GENERAL;

        /*
        te = G_TempEntity( vec3_origin, EV_DESTROY_GHOUL2_INSTANCE );
        te->r.svFlags |= SVF_BROADCAST;
        te->s.eventParm = self->s.number;
        */
        G_KillG2Queue(self->s.number);

        return;
}

gentity_t *gJMSaberEnt = NULL;

/*QUAKED info_jedimaster_start (1 0 0) (-16 -16 -24) (16 16 32)
"jedi master" saber spawn point
*/
void SP_info_jedimaster_start(gentity_t *ent)
{
        if (g_gametype.integer != GT_JEDIMASTER)
        {
                gJMSaberEnt = NULL;
                G_FreeEntity(ent);
                return;
        }

        ent->enemy = NULL;

        ent->flags = FL_BOUNCE_HALF;

        ent->s.modelindex = G_ModelIndex("models/weapons2/saber/saber_w.glm");
        ent->s.modelGhoul2 = 1;
        ent->s.g2radius = 20;
        //ent->s.eType = ET_GENERAL;
        ent->s.eType = ET_MISSILE;
        ent->s.weapon = WP_SABER;
        ent->s.pos.trType = TR_GRAVITY;
        ent->s.pos.trTime = level.time;
        VectorSet( ent->r.maxs, 3, 3, 3 );
        VectorSet( ent->r.mins, -3, -3, -3 );
        ent->r.contents = CONTENTS_TRIGGER;
        ent->clipmask = MASK_SOLID;

        ent->isSaberEntity = qtrue;

        ent->bounceCount = -5;

        ent->physicsObject = qtrue;

        VectorCopy(ent->s.pos.trBase, ent->s.origin2); //remember the spawn spot

        ent->touch = JMSaberTouch;

        trap_LinkEntity(ent);

        ent->think = JMSaberThink;
        ent->nextthink = level.time + 50;
}

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

  SelectSpawnPoint

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

/*
================
SpotWouldTelefrag

================
*/
qboolean SpotWouldTelefrag( gentity_t *spot ) {
        int                     i, num;
        int                     touch[MAX_GENTITIES];
        gentity_t       *hit;
        vec3_t          mins, maxs;

        VectorAdd( spot->s.origin, playerMins, mins );
        VectorAdd( spot->s.origin, playerMaxs, maxs );
        num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

        for (i=0 ; i<num ; i++) {
                hit = &g_entities[touch[i]];
                //if ( hit->client && hit->client->ps.stats[STAT_HEALTH] > 0 ) {
                if ( hit->client) {
                        return qtrue;
                }

        }

        return qfalse;
}

qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest ) 
{
        int                     i, num;
        int                     touch[MAX_GENTITIES];
        gentity_t       *hit;
        vec3_t          mins, maxs;

        VectorAdd( dest, mover->r.mins, mins );
        VectorAdd( dest, mover->r.maxs, maxs );
        num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

        for (i=0 ; i<num ; i++) 
        {
                hit = &g_entities[touch[i]];
                if ( hit == mover )
                {
                        continue;
                }

                if ( hit->r.contents & mover->r.contents )
                {
                        return qtrue;
                }
        }

        return qfalse;
}

/*
================
SelectNearestDeathmatchSpawnPoint

Find the spot that we DON'T want to use
================
*/
#define MAX_SPAWN_POINTS        128
gentity_t *SelectNearestDeathmatchSpawnPoint( vec3_t from ) {
        gentity_t       *spot;
        vec3_t          delta;
        float           dist, nearestDist;
        gentity_t       *nearestSpot;

        nearestDist = 999999;
        nearestSpot = NULL;
        spot = NULL;

        while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {

                VectorSubtract( spot->s.origin, from, delta );
                dist = VectorLength( delta );
                if ( dist < nearestDist ) {
                        nearestDist = dist;
                        nearestSpot = spot;
                }
        }

        return nearestSpot;
}


/*
================
SelectRandomDeathmatchSpawnPoint

go to a random point that doesn't telefrag
================
*/
#define MAX_SPAWN_POINTS        128
gentity_t *SelectRandomDeathmatchSpawnPoint( void ) {
        gentity_t       *spot;
        int                     count;
        int                     selection;
        gentity_t       *spots[MAX_SPAWN_POINTS];

        count = 0;
        spot = NULL;

        while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
                if ( SpotWouldTelefrag( spot ) ) {
                        continue;
                }
                spots[ count ] = spot;
                count++;
        }

        if ( !count ) { // no spots that won't telefrag
                return G_Find( NULL, FOFS(classname), "info_player_deathmatch");
        }

        selection = rand() % count;
        return spots[ selection ];
}

/*
===========
SelectRandomFurthestSpawnPoint

Chooses a player start, deathmatch start, etc
============
*/
gentity_t *SelectRandomFurthestSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles, team_t team ) {
        gentity_t       *spot;
        vec3_t          delta;
        float           dist;
        float           list_dist[64];
        gentity_t       *list_spot[64];
        int                     numSpots, rnd, i, j;

        numSpots = 0;
        spot = NULL;

        //in Team DM, look for a team start spot first, if any
        if ( g_gametype.integer == GT_TEAM 
                && team != TEAM_FREE 
                && team != TEAM_SPECTATOR )
        {
                char *classname = NULL;
                if ( team == TEAM_RED )
                {
                        classname = "info_player_start_red";
                }
                else
                {
                        classname = "info_player_start_blue";
                }
                while ((spot = G_Find (spot, FOFS(classname), classname)) != NULL) {
                        if ( SpotWouldTelefrag( spot ) ) {
                                continue;
                        }
                        VectorSubtract( spot->s.origin, avoidPoint, delta );
                        dist = VectorLength( delta );
                        for (i = 0; i < numSpots; i++) {
                                if ( dist > list_dist[i] ) {
                                        if ( numSpots >= 64 )
                                                numSpots = 64-1;
                                        for (j = numSpots; j > i; j--) {
                                                list_dist[j] = list_dist[j-1];
                                                list_spot[j] = list_spot[j-1];
                                        }
                                        list_dist[i] = dist;
                                        list_spot[i] = spot;
                                        numSpots++;
                                        if (numSpots > 64)
                                                numSpots = 64;
                                        break;
                                }
                        }
                        if (i >= numSpots && numSpots < 64) {
                                list_dist[numSpots] = dist;
                                list_spot[numSpots] = spot;
                                numSpots++;
                        }
                }
        }

        if ( !numSpots )
        {//couldn't find any of the above
                while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
                        if ( SpotWouldTelefrag( spot ) ) {
                                continue;
                        }
                        VectorSubtract( spot->s.origin, avoidPoint, delta );
                        dist = VectorLength( delta );
                        for (i = 0; i < numSpots; i++) {
                                if ( dist > list_dist[i] ) {
                                        if ( numSpots >= 64 )
                                                numSpots = 64-1;
                                        for (j = numSpots; j > i; j--) {
                                                list_dist[j] = list_dist[j-1];
                                                list_spot[j] = list_spot[j-1];
                                        }
                                        list_dist[i] = dist;
                                        list_spot[i] = spot;
                                        numSpots++;
                                        if (numSpots > 64)
                                                numSpots = 64;
                                        break;
                                }
                        }
                        if (i >= numSpots && numSpots < 64) {
                                list_dist[numSpots] = dist;
                                list_spot[numSpots] = spot;
                                numSpots++;
                        }
                }
                if (!numSpots) {
                        spot = G_Find( NULL, FOFS(classname), "info_player_deathmatch");
                        if (!spot)
                                G_Error( "Couldn't find a spawn point" );
                        VectorCopy (spot->s.origin, origin);
                        origin[2] += 9;
                        VectorCopy (spot->s.angles, angles);
                        return spot;
                }
        }

        // select a random spot from the spawn points furthest away
        rnd = random() * (numSpots / 2);

        VectorCopy (list_spot[rnd]->s.origin, origin);
        origin[2] += 9;
        VectorCopy (list_spot[rnd]->s.angles, angles);

        return list_spot[rnd];
}

gentity_t *SelectDuelSpawnPoint( int team, vec3_t avoidPoint, vec3_t origin, vec3_t angles )
{
        gentity_t       *spot;
        vec3_t          delta;
        float           dist;
        float           list_dist[64];
        gentity_t       *list_spot[64];
        int                     numSpots, rnd, i, j;
        char            *spotName;

        if (team == DUELTEAM_LONE)
        {
                spotName = "info_player_duel1";
        }
        else if (team == DUELTEAM_DOUBLE)
        {
                spotName = "info_player_duel2";
        }
        else if (team == DUELTEAM_SINGLE)
        {
                spotName = "info_player_duel";
        }
        else
        {
                spotName = "info_player_deathmatch";
        }
tryAgain:

        numSpots = 0;
        spot = NULL;

        while ((spot = G_Find (spot, FOFS(classname), spotName)) != NULL) {
                if ( SpotWouldTelefrag( spot ) ) {
                        continue;
                }
                VectorSubtract( spot->s.origin, avoidPoint, delta );
                dist = VectorLength( delta );
                for (i = 0; i < numSpots; i++) {
                        if ( dist > list_dist[i] ) {
                                if ( numSpots >= 64 )
                                        numSpots = 64-1;
                                for (j = numSpots; j > i; j--) {
                                        list_dist[j] = list_dist[j-1];
                                        list_spot[j] = list_spot[j-1];
                                }
                                list_dist[i] = dist;
                                list_spot[i] = spot;
                                numSpots++;
                                if (numSpots > 64)
                                        numSpots = 64;
                                break;
                        }
                }
                if (i >= numSpots && numSpots < 64) {
                        list_dist[numSpots] = dist;
                        list_spot[numSpots] = spot;
                        numSpots++;
                }
        }
        if (!numSpots)
        {
                if (Q_stricmp(spotName, "info_player_deathmatch"))
                { //try the loop again with info_player_deathmatch as the target if we couldn't find a duel spot
                        spotName = "info_player_deathmatch";
                        goto tryAgain;
                }

                //If we got here we found no free duel or DM spots, just try the first DM spot
                spot = G_Find( NULL, FOFS(classname), "info_player_deathmatch");
                if (!spot)
                        G_Error( "Couldn't find a spawn point" );
                VectorCopy (spot->s.origin, origin);
                origin[2] += 9;
                VectorCopy (spot->s.angles, angles);
                return spot;
        }

        // select a random spot from the spawn points furthest away
        rnd = random() * (numSpots / 2);

        VectorCopy (list_spot[rnd]->s.origin, origin);
        origin[2] += 9;
        VectorCopy (list_spot[rnd]->s.angles, angles);

        return list_spot[rnd];
}

/*
===========
SelectSpawnPoint

Chooses a player start, deathmatch start, etc
============
*/
gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles, team_t team ) {
        return SelectRandomFurthestSpawnPoint( avoidPoint, origin, angles, team );

        /*
        gentity_t       *spot;
        gentity_t       *nearestSpot;

        nearestSpot = SelectNearestDeathmatchSpawnPoint( avoidPoint );

        spot = SelectRandomDeathmatchSpawnPoint ( );
        if ( spot == nearestSpot ) {
                // roll again if it would be real close to point of death
                spot = SelectRandomDeathmatchSpawnPoint ( );
                if ( spot == nearestSpot ) {
                        // last try
                        spot = SelectRandomDeathmatchSpawnPoint ( );
                }               
        }

        // find a single player start spot
        if (!spot) {
                G_Error( "Couldn't find a spawn point" );
        }

        VectorCopy (spot->s.origin, origin);
        origin[2] += 9;
        VectorCopy (spot->s.angles, angles);

        return spot;
        */
}

/*
===========
SelectInitialSpawnPoint

Try to find a spawn point marked 'initial', otherwise
use normal spawn selection.
============
*/
gentity_t *SelectInitialSpawnPoint( vec3_t origin, vec3_t angles, team_t team ) {
        gentity_t       *spot;

        spot = NULL;
        while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
                if ( spot->spawnflags & 1 ) {
                        break;
                }
        }

        if ( !spot || SpotWouldTelefrag( spot ) ) {
                return SelectSpawnPoint( vec3_origin, origin, angles, team );
        }

        VectorCopy (spot->s.origin, origin);
        origin[2] += 9;
        VectorCopy (spot->s.angles, angles);

        return spot;
}

/*
===========
SelectSpectatorSpawnPoint

============
*/
gentity_t *SelectSpectatorSpawnPoint( vec3_t origin, vec3_t angles ) {
        FindIntermissionPoint();

        VectorCopy( level.intermission_origin, origin );
        VectorCopy( level.intermission_angle, angles );

        return NULL;
}

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

BODYQUE

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

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

BODYQUE

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

#define BODY_SINK_TIME          30000//45000

/*
===============
InitBodyQue
===============
*/
void InitBodyQue (void) {
        int             i;
        gentity_t       *ent;

        level.bodyQueIndex = 0;
        for (i=0; i<BODY_QUEUE_SIZE ; i++) {
                ent = G_Spawn();
                ent->classname = "bodyque";
                ent->neverFree = qtrue;
                level.bodyQue[i] = ent;
        }
}

/*
=============
BodySink

After sitting around for five seconds, fall into the ground and dissapear
=============
*/
void BodySink( gentity_t *ent ) {
        if ( level.time - ent->timestamp > BODY_SINK_TIME + 2500 ) {
                // the body ques are never actually freed, they are just unlinked
                trap_UnlinkEntity( ent );
                ent->physicsObject = qfalse;
                return; 
        }
//      ent->nextthink = level.time + 100;
//      ent->s.pos.trBase[2] -= 1;

        G_AddEvent(ent, EV_BODYFADE, 0);
        ent->nextthink = level.time + 18000;
        ent->takedamage = qfalse;
}

/*
=============
CopyToBodyQue

A player is respawning, so make an entity that looks
just like the existing corpse to leave behind.
=============
*/
static qboolean CopyToBodyQue( gentity_t *ent ) {
        gentity_t               *body;
        int                     contents;
        int                     islight = 0;

        if (level.intermissiontime)
        {
                return qfalse;
        }

        trap_UnlinkEntity (ent);

        // if client is in a nodrop area, don't leave the body
        contents = trap_PointContents( ent->s.origin, -1 );
        if ( contents & CONTENTS_NODROP ) {
                return qfalse;
        }

        if (ent->client && (ent->client->ps.eFlags & EF_DISINTEGRATION))
        { //for now, just don't spawn a body if you got disint'd
                return qfalse;
        }

        // grab a body que and cycle to the next one
        body = level.bodyQue[ level.bodyQueIndex ];
        level.bodyQueIndex = (level.bodyQueIndex + 1) % BODY_QUEUE_SIZE;

        trap_UnlinkEntity (body);
        body->s = ent->s;

        //avoid oddly angled corpses floating around
        body->s.angles[PITCH] = body->s.angles[ROLL] = body->s.apos.trBase[PITCH] = body->s.apos.trBase[ROLL] = 0;

        body->s.g2radius = 100;

        body->s.eType = ET_BODY;
        body->s.eFlags = EF_DEAD;               // clear EF_TALK, etc

        if (ent->client && (ent->client->ps.eFlags & EF_DISINTEGRATION))
        {
                body->s.eFlags |= EF_DISINTEGRATION;
        }

        VectorCopy(ent->client->ps.lastHitLoc, body->s.origin2);

        body->s.powerups = 0;   // clear powerups
        body->s.loopSound = 0;  // clear lava burning
        body->s.loopIsSoundset = qfalse;
        body->s.number = body - g_entities;
        body->timestamp = level.time;
        body->physicsObject = qtrue;
        body->physicsBounce = 0;                // don't bounce
        if ( body->s.groundEntityNum == ENTITYNUM_NONE ) {
                body->s.pos.trType = TR_GRAVITY;
                body->s.pos.trTime = level.time;
                VectorCopy( ent->client->ps.velocity, body->s.pos.trDelta );
        } else {
                body->s.pos.trType = TR_STATIONARY;
        }
        body->s.event = 0;

        body->s.weapon = ent->s.bolt2;

        if (body->s.weapon == WP_SABER && ent->client->ps.saberInFlight)
        {
                body->s.weapon = WP_BLASTER; //lie to keep from putting a saber on the corpse, because it was thrown at death
        }

        //G_AddEvent(body, EV_BODY_QUEUE_COPY, ent->s.clientNum);
        //Now doing this through a modified version of the rcg reliable command.
        if (ent->client && ent->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
        {
                islight = 1;
        }
        trap_SendServerCommand(-1, va("ircg %i %i %i %i", ent->s.number, body->s.number, body->s.weapon, islight));

        body->r.svFlags = ent->r.svFlags | SVF_BROADCAST;
        VectorCopy (ent->r.mins, body->r.mins);
        VectorCopy (ent->r.maxs, body->r.maxs);
        VectorCopy (ent->r.absmin, body->r.absmin);
        VectorCopy (ent->r.absmax, body->r.absmax);

        body->s.torsoAnim = body->s.legsAnim = ent->client->ps.legsAnim;

        body->s.customRGBA[0] = ent->client->ps.customRGBA[0];
        body->s.customRGBA[1] = ent->client->ps.customRGBA[1];
        body->s.customRGBA[2] = ent->client->ps.customRGBA[2];
        body->s.customRGBA[3] = ent->client->ps.customRGBA[3];

        body->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
        body->r.contents = CONTENTS_CORPSE;
        body->r.ownerNum = ent->s.number;

        body->nextthink = level.time + BODY_SINK_TIME;
        body->think = BodySink;

        body->die = body_die;

        // don't take more damage if already gibbed
        if ( ent->health <= GIB_HEALTH ) {
                body->takedamage = qfalse;
        } else {
                body->takedamage = qtrue;
        }

        VectorCopy ( body->s.pos.trBase, body->r.currentOrigin );
        trap_LinkEntity (body);

        return qtrue;
}

//======================================================================


/*
==================
SetClientViewAngle

==================
*/
void SetClientViewAngle( gentity_t *ent, vec3_t angle ) {
        int                     i;

        // set the delta angle
        for (i=0 ; i<3 ; i++) {
                int             cmdAngle;

                cmdAngle = ANGLE2SHORT(angle[i]);
                ent->client->ps.delta_angles[i] = cmdAngle - ent->client->pers.cmd.angles[i];
        }
        VectorCopy( angle, ent->s.angles );
        VectorCopy (ent->s.angles, ent->client->ps.viewangles);
}

void MaintainBodyQueue(gentity_t *ent)
{ //do whatever should be done taking ragdoll and dismemberment states into account.
        qboolean doRCG = qfalse;

        assert(ent && ent->client);
        if (ent->client->tempSpectate > level.time ||
                (ent->client->ps.eFlags2 & EF2_SHIP_DEATH))
        {
                ent->client->noCorpse = qtrue;
        }

        if (!ent->client->noCorpse && !ent->client->ps.fallingToDeath)
        {
                if (!CopyToBodyQue (ent))
                {
                        doRCG = qtrue;
                }
        }
        else
        {
                ent->client->noCorpse = qfalse; //clear it for next time
                ent->client->ps.fallingToDeath = qfalse;
                doRCG = qtrue;
        }

        if (doRCG)
        { //bodyque func didn't manage to call ircg so call this to assure our limbs and ragdoll states are proper on the client.
                trap_SendServerCommand(-1, va("rcg %i", ent->s.clientNum));
        }
}

/*
================
respawn
================
*/
void SiegeRespawn(gentity_t *ent);
void respawn( gentity_t *ent ) {
        MaintainBodyQueue(ent);

        if (gEscaping || g_gametype.integer == GT_POWERDUEL)
        {
                ent->client->sess.sessionTeam = TEAM_SPECTATOR;
                ent->client->sess.spectatorState = SPECTATOR_FREE;
                ent->client->sess.spectatorClient = 0;

                ent->client->pers.teamState.state = TEAM_BEGIN;
                ent->client->sess.spectatorTime = level.time;
                ClientSpawn(ent);
                ent->client->iAmALoser = qtrue;
                return;
        }

        trap_UnlinkEntity (ent);

        if (g_gametype.integer == GT_SIEGE)
        {
                if (g_siegeRespawn.integer)
                {
                        if (ent->client->tempSpectate <= level.time)
                        {
                                int minDel = g_siegeRespawn.integer* 2000;
                                if (minDel < 20000)
                                {
                                        minDel = 20000;
                                }
                                ent->client->tempSpectate = level.time + minDel;
                                ent->health = ent->client->ps.stats[STAT_HEALTH] = 1;
                                ent->client->ps.weapon = WP_NONE;
                                ent->client->ps.stats[STAT_WEAPONS] = 0;
                                ent->client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
                                ent->client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
                                ent->takedamage = qfalse;
                                trap_LinkEntity(ent);

                                // Respawn time.
                                if ( ent->s.number < MAX_CLIENTS )
                                {
                                        gentity_t *te = G_TempEntity( ent->client->ps.origin, EV_SIEGESPEC );
                                        te->s.time = g_siegeRespawnCheck;
                                        te->s.owner = ent->s.number;
                                }

                                return;
                        }
                }
                SiegeRespawn(ent);
        }
        else
        {
                gentity_t       *tent;

                ClientSpawn(ent);

                // add a teleportation effect
                tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
                tent->s.clientNum = ent->s.clientNum;
        }
}

/*
================
TeamCount

Returns number of players on a team
================
*/
team_t TeamCount( int ignoreClientNum, int team ) {
        int             i;
        int             count = 0;

        for ( i = 0 ; i < level.maxclients ; i++ ) {
                if ( i == ignoreClientNum ) {
                        continue;
                }
                if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
                        continue;
                }
                if ( level.clients[i].sess.sessionTeam == team ) {
                        count++;
                }
                else if (g_gametype.integer == GT_SIEGE &&
            level.clients[i].sess.siegeDesiredTeam == team)
                {
                        count++;
                }
        }

        return count;
}

/*
================
TeamLeader

Returns the client number of the team leader
================
*/
int TeamLeader( int team ) {
        int             i;

        for ( i = 0 ; i < level.maxclients ; i++ ) {
                if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
                        continue;
                }
                if ( level.clients[i].sess.sessionTeam == team ) {
                        if ( level.clients[i].sess.teamLeader )
                                return i;
                }
        }

        return -1;
}


/*
================
PickTeam

================
*/
team_t PickTeam( int ignoreClientNum ) {
        int             counts[TEAM_NUM_TEAMS];

        counts[TEAM_BLUE] = TeamCount( ignoreClientNum, TEAM_BLUE );
        counts[TEAM_RED] = TeamCount( ignoreClientNum, TEAM_RED );

        if ( counts[TEAM_BLUE] > counts[TEAM_RED] ) {