/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2002-2021 Q3Rally Team (Per Thormann - q3rally@gmail.com)

This file is part of q3rally source code.

q3rally source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

q3rally source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with q3rally; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
#include "g_local.h"

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

// STONELANCE
/*
static vec3_t	playerMins = {-15, -15, -24};
static vec3_t	playerMaxs = {15, 15, 32};
*/
static vec3_t	playerMins = {-CAR_WIDTH/2, -CAR_WIDTH/2, -CAR_WIDTH/2};
static vec3_t	playerMaxs = {CAR_WIDTH/2, CAR_WIDTH/2, CAR_WIDTH/2};

//static vec3_t	playerMins = {-CAR_LENGTH/2, -CAR_WIDTH/2, -CAR_HEIGHT/2};
//static vec3_t	playerMaxs = {CAR_LENGTH/2, CAR_WIDTH/2, CAR_HEIGHT/2};
// END

/*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)
equivalent to info_player_deathmatch
*/
void SP_info_player_start(gentity_t *ent) {
// STONELANCE
/*
	ent->classname = "info_player_deathmatch";
	SP_info_player_deathmatch( ent );
*/
// END
}

/*QUAKED info_player_intermission (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.
*/
void SP_info_player_intermission( gentity_t *ent ) {

}



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

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

/*
================
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(qboolean isbot) {
	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 && count < MAX_SPAWN_POINTS)
	{
		if(SpotWouldTelefrag(spot))
			continue;

		if(((spot->flags & FL_NO_BOTS) && isbot) ||
		   ((spot->flags & FL_NO_HUMANS) && !isbot))
		{
			// spot is not for this human/bot player
			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, qboolean isbot ) {
	gentity_t	*spot;
	vec3_t		delta;
	float		dist;
	float		list_dist[MAX_SPAWN_POINTS];
	gentity_t	*list_spot[MAX_SPAWN_POINTS];
	int			numSpots, rnd, i, j;

	numSpots = 0;
	spot = NULL;

	while((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
	{
		if(SpotWouldTelefrag(spot))
			continue;

		if(((spot->flags & FL_NO_BOTS) && isbot) ||
		   ((spot->flags & FL_NO_HUMANS) && !isbot))
		{
			// spot is not for this human/bot player
			continue;
		}

		VectorSubtract( spot->s.origin, avoidPoint, delta );
		dist = VectorLength( delta );

		for (i = 0; i < numSpots; i++)
		{
			if(dist > list_dist[i])
			{
				if (numSpots >= MAX_SPAWN_POINTS)
					numSpots = MAX_SPAWN_POINTS - 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++;
				break;
			}
		}
		
		if(i >= numSpots && numSpots < MAX_SPAWN_POINTS)
		{
			list_dist[numSpots] = dist;
			list_spot[numSpots] = spot;
			numSpots++;
		}
	}
	
	if(!numSpots)
	{
		spot = G_Find(NULL, FOFS(classname), "info_player_deathmatch");

// STONELANCE
//		if (!spot)
//			G_Error( "Couldn't find a spawn point" );
		if (!spot){
			G_Printf( "Warning: Couldn't find a deathmatch spawn point\n" );
			spot = G_Find( NULL, FOFS(classname), "info_player_start");
			if (!spot)
				G_Error( "Couldn't find a spawn point" );
		}
// END

		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, qboolean isbot ) {
	return SelectRandomFurthestSpawnPoint( avoidPoint, origin, angles, isbot );

	/*
	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, qboolean isbot ) {
	gentity_t	*spot;

	spot = NULL;
	
	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
	{
		if(((spot->flags & FL_NO_BOTS) && isbot) ||
		   ((spot->flags & FL_NO_HUMANS) && !isbot))
		{
			continue;
		}
		
		if((spot->spawnflags & 0x01))
			break;
	}

	if (!spot || SpotWouldTelefrag(spot))
		return SelectSpawnPoint(vec3_origin, origin, angles, isbot);

	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

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

/*
===============
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 disappear
=============
*/
void BodySink( gentity_t *ent ) {
	if ( level.time - ent->timestamp > 6500 ) {
// STONELANCE
		if ( ent->frontBounds ){
			G_FreeEntity( ent->frontBounds );
			ent->frontBounds = NULL;
		}
		if ( ent->rearBounds ){
			G_FreeEntity( ent->rearBounds );
			ent->rearBounds = NULL;
		}
// END

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

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

A player is respawning, so make an entity that looks
just like the existing corpse to leave behind.
=============
*/
void CopyToBodyQue( gentity_t *ent ) {
#ifdef MISSIONPACK
	gentity_t	*e;
	int i;
#endif
	gentity_t		*body;
	int			contents;

	trap_UnlinkEntity (ent);

// STONELANCE
	// if the player is already dead dont worry about copying the body
	if ( ent->client->ps.stats[STAT_HEALTH] <= GIB_HEALTH )
		return;
// END

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

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

	body->s = ent->s;
	body->s.eFlags = EF_DEAD;		// clear EF_TALK, etc
#ifdef MISSIONPACK
	if ( ent->s.eFlags & EF_KAMIKAZE ) {
		body->s.eFlags |= EF_KAMIKAZE;

		// check if there is a kamikaze timer around for this owner
		for (i = 0; i < level.num_entities; i++) {
			e = &g_entities[i];
			if (!e->inuse)
				continue;
			if (e->activator != ent)
				continue;
			if (strcmp(e->classname, "kamikaze timer"))
				continue;
			e->activator = body;
			break;
		}
	}
#endif
	body->s.powerups = 0;	// clear powerups
	body->s.loopSound = 0;	// clear lava burning
	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;

// STONELANCE
	if ( ent->frontBounds ){ // there should always be an ent->frontBounds, but just in case
		body->frontBounds = G_Spawn();
		VectorCopy (ent->frontBounds->r.mins, body->frontBounds->r.mins);
		VectorCopy (ent->frontBounds->r.maxs, body->frontBounds->r.maxs);
		body->frontBounds->r.svFlags = SVF_NOCLIENT;
		body->frontBounds->flags = FL_EXTRA_BBOX;
		G_SetOrigin( body->frontBounds, ent->frontBounds->r.currentOrigin );
		body->frontBounds->r.ownerNum = body->s.number;
		body->frontBounds->r.contents = CONTENTS_CORPSE;
		trap_LinkEntity ( body->frontBounds );
	}

	if ( ent->rearBounds ){ // there should always be an ent->rearBounds, but just in case
		body->rearBounds = G_Spawn();
		VectorCopy (ent->rearBounds->r.mins, body->rearBounds->r.mins);
		VectorCopy (ent->rearBounds->r.maxs, body->rearBounds->r.maxs);
		body->rearBounds->r.svFlags = SVF_NOCLIENT;
		body->rearBounds->flags = FL_EXTRA_BBOX;
		G_SetOrigin( body->rearBounds, ent->rearBounds->r.currentOrigin );
		body->rearBounds->r.ownerNum = body->s.number;
		body->rearBounds->r.contents = CONTENTS_CORPSE;
		trap_LinkEntity ( body->rearBounds );
	}
// END

	// change the animation to the last-frame only, so the sequence
	// doesn't repeat anew for the body
// STONELANCE
/*
	switch ( body->s.legsAnim & ~ANIM_TOGGLEBIT ) {
	case BOTH_DEATH1:
	case BOTH_DEAD1:
		body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD1;
		break;
	case BOTH_DEATH2:
	case BOTH_DEAD2:
		body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD2;
		break;
	case BOTH_DEATH3:
	case BOTH_DEAD3:
	default:
		body->s.torsoAnim = body->s.legsAnim = BOTH_DEAD3;
		break;
	}
*/
// END

	body->r.svFlags = ent->r.svFlags;
	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->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
	body->r.contents = CONTENTS_CORPSE;
	body->r.ownerNum = ent->s.number;

	body->nextthink = level.time + 5000;
	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);
}

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


/*
==================
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);
// STONELANCE
	VectorCopy( angle, ent->s.angles2 );
	ent->client->ps.damagePitch = ANGLE2SHORT(ent->s.angles2[PITCH]);
	ent->client->ps.damageYaw = ANGLE2SHORT(ent->s.angles2[YAW]);
// END
}

/*
================
ClientRespawn
================
*/
void ClientRespawn( gentity_t *ent ) {

	CopyToBodyQue (ent);
	ClientSpawn(ent);
}

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

Returns number of players on a team
================
*/
int TeamCount( int ignoreClientNum, team_t 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++;
		}
	}

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


// STONELANCE
team_t LowestTeamCount( int ignoreClientNum ){
	int		counts[TEAM_NUM_TEAMS];

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

	if ( counts[TEAM_BLUE] == counts[TEAM_RED]
		&& counts[TEAM_BLUE] == counts[TEAM_GREEN]
		&& counts[TEAM_BLUE] == counts[TEAM_YELLOW]) {
		return 0;
	}

	if ( counts[TEAM_BLUE] <= counts[TEAM_RED]
		&& counts[TEAM_BLUE] <= counts[TEAM_GREEN]
		&& counts[TEAM_BLUE] <= counts[TEAM_YELLOW]) {
		return TEAM_BLUE;
	}
	if ( counts[TEAM_RED] <= counts[TEAM_BLUE]
		&& counts[TEAM_RED] <= counts[TEAM_GREEN]
		&& counts[TEAM_RED] <= counts[TEAM_YELLOW]) {
		return TEAM_RED;
	}
	if ( counts[TEAM_GREEN] <= counts[TEAM_RED]
		&& counts[TEAM_GREEN] <= counts[TEAM_BLUE]
		&& counts[TEAM_GREEN] <= counts[TEAM_YELLOW]) {
		return TEAM_GREEN;
	}
	if ( counts[TEAM_YELLOW] <= counts[TEAM_RED]
		&& counts[TEAM_YELLOW] <= counts[TEAM_GREEN]
		&& counts[TEAM_YELLOW] <= counts[TEAM_YELLOW]) {
		return TEAM_YELLOW;
	}

	return 0;
}

team_t LowestTeamScore( void ){
	if ( level.teamScores[TEAM_BLUE] == level.teamScores[TEAM_RED]
		&& level.teamScores[TEAM_BLUE] == level.teamScores[TEAM_GREEN]
		&& level.teamScores[TEAM_BLUE] == level.teamScores[TEAM_YELLOW]) {
		return 0;
	}

	if ( level.teamScores[TEAM_BLUE] <= level.teamScores[TEAM_RED]
		&& level.teamScores[TEAM_BLUE] <= level.teamScores[TEAM_GREEN]
		&& level.teamScores[TEAM_BLUE] <= level.teamScores[TEAM_YELLOW]) {
		return TEAM_BLUE;
	}
	if ( level.teamScores[TEAM_RED] <= level.teamScores[TEAM_BLUE]
		&& level.teamScores[TEAM_RED] <= level.teamScores[TEAM_GREEN]
		&& level.teamScores[TEAM_RED] <= level.teamScores[TEAM_YELLOW]) {
		return TEAM_RED;
	}
	if ( level.teamScores[TEAM_GREEN] <= level.teamScores[TEAM_RED]
		&& level.teamScores[TEAM_GREEN] <= level.teamScores[TEAM_BLUE]
		&& level.teamScores[TEAM_GREEN] <= level.teamScores[TEAM_YELLOW]) {
		return TEAM_GREEN;
	}
	if ( level.teamScores[TEAM_YELLOW] <= level.teamScores[TEAM_RED]
		&& level.teamScores[TEAM_YELLOW] <= level.teamScores[TEAM_GREEN]
		&& level.teamScores[TEAM_YELLOW] <= level.teamScores[TEAM_YELLOW]) {
		return TEAM_YELLOW;
	}

	return 0;
}
// END


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

================
*/
team_t PickTeam( int ignoreClientNum ) {
// STONELANCE
/*
	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] ) {
		return TEAM_RED;
	}
	if ( counts[TEAM_RED] > counts[TEAM_BLUE] ) {
		return TEAM_BLUE;
	}
	// equal team count, so join the team with the lowest score
	if ( level.teamScores[TEAM_BLUE] > level.teamScores[TEAM_RED] ) {
		return TEAM_RED;
	}
*/
	int		team;

	if ( (team = LowestTeamCount(ignoreClientNum)) ){
		return team;
	}

	// equal team count, so join the team with the lowest score
	if ( (team = LowestTeamScore()) ){
		return team;
	}
// END

	return TEAM_BLUE;
}

/*
===========
ForceClientSkin

Forces a client's skin (for teamplay)
===========
*/
/*
static void ForceClientSkin( gclient_t *client, char *model, const char *skin ) {
	char *p;

	if ((p = strrchr(model, '/')) != 0) {
		*p = 0;
	}

	Q_strcat(model, MAX_QPATH, "/");
	Q_strcat(model, MAX_QPATH, skin);
}
*/

/*
===========
ClientCleanName
============
*/
static void ClientCleanName(const char *in, char *out, int outSize)
{
	int outpos = 0, colorlessLen = 0, spaces = 0;

	// discard leading spaces
	for(; *in == ' '; in++);
	
	for(; *in && outpos < outSize - 1; in++)
	{
		out[outpos] = *in;

		if(*in == ' ')
		{
			// don't allow too many consecutive spaces
			if(spaces > 2)
				continue;
			
			spaces++;
		}
		else if(outpos > 0 && out[outpos - 1] == Q_COLOR_ESCAPE)
		{
			if(Q_IsColorString(&out[outpos - 1]))
			{
				colorlessLen--;
				
// STONELANCE
/*
				if(ColorIndex(*in) == 0)
				{
					// Disallow color black in names to prevent players
					// from getting advantage playing in front of black backgrounds
					outpos--;
					continue;
				}
*/
// END
			}
			else
			{
				spaces = 0;
				colorlessLen++;
			}
		}
		else
		{
			spaces = 0;
			colorlessLen++;
		}
		
		outpos++;
	}

	out[outpos] = '\0';

	// don't allow empty names
	if( *out == '\0' || colorlessLen == 0)
		Q_strncpyz(out, "UnnamedPlayer", outSize );
}


/*
===========
ClientUserInfoChanged

Called from ClientConnect when the player first connects and
directly by the server system when the player updates a userinfo variable.

The game can override any of the settings and call trap_SetUserinfo
if desired.
============
*/
void ClientUserinfoChanged( int clientNum ) {
	gentity_t *ent;
	int		teamTask, teamLeader, health;
	char	*s;
	char	model[MAX_QPATH];
	char	headModel[MAX_QPATH];
// STONELANCE
	char	rim[MAX_QPATH];
	char	plate[MAX_QPATH];
// END
	char	oldname[MAX_STRING_CHARS];
	gclient_t	*client;
	char	c1[MAX_INFO_STRING];
	char	c2[MAX_INFO_STRING];
	char	redTeam[MAX_INFO_STRING];
	char	blueTeam[MAX_INFO_STRING];
	char	userinfo[MAX_INFO_STRING];

	ent = g_entities + clientNum;
	client = ent->client;

	trap_GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );

	// check for malformed or illegal info strings
	if ( !Info_Validate(userinfo) ) {
		strcpy (userinfo, "\\name\\badinfo");
		// don't keep those clients and userinfo
		trap_DropClient(clientNum, "Invalid userinfo");
	}

	// check the item prediction
	s = Info_ValueForKey( userinfo, "cg_predictItems" );
	if ( !atoi( s ) ) {
		client->pers.predictItemPickup = qfalse;
	} else {
		client->pers.predictItemPickup = qtrue;
	}

	// set name
	Q_strncpyz ( oldname, client->pers.netname, sizeof( oldname ) );
	s = Info_ValueForKey (userinfo, "name");
	ClientCleanName( s, client->pers.netname, sizeof(client->pers.netname) );

	if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
			Q_strncpyz( client->pers.netname, "scoreboard", sizeof(client->pers.netname) );
		}
	}

	if ( client->pers.connected == CON_CONNECTED ) {
		if ( strcmp( oldname, client->pers.netname ) ) {
			trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " renamed to %s\n\"", oldname, 
				client->pers.netname) );
		}
	}

	// set max health
#ifdef MISSIONPACK
	if (client->ps.powerups[PW_GUARD]) {
		client->pers.maxHealth = 200;
	} else {
		health = atoi( Info_ValueForKey( userinfo, "handicap" ) );
		client->pers.maxHealth = health;
		if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
			client->pers.maxHealth = 100;
		}
	}
#else
	health = atoi( Info_ValueForKey( userinfo, "handicap" ) );
	client->pers.maxHealth = health;
	if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
		client->pers.maxHealth = 100;
	}
#endif
	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;

	// set model
// STONELANCE
/*
	if( g_gametype.integer >= GT_TEAM ) {
		Q_strncpyz( model, Info_ValueForKey (userinfo, "team_model"), sizeof( model ) );
		Q_strncpyz( headModel, Info_ValueForKey (userinfo, "team_headmodel"), sizeof( headModel ) );
	} else {
*/
// END
		Q_strncpyz( model, Info_ValueForKey (userinfo, "model"), sizeof( model ) );
// STONELANCE
//		Q_strncpyz( headModel, Info_ValueForKey (userinfo, "headmodel"), sizeof( headModel ) );
		Q_strncpyz( headModel, Info_ValueForKey (userinfo, "head"), sizeof( headModel ) );
//	}
// END

/*	NOTE: all client side now

	// team
	switch( team ) {
	case TEAM_RED:
		ForceClientSkin(client, model, "red");
//		ForceClientSkin(client, headModel, "red");
		break;
	case TEAM_BLUE:
		ForceClientSkin(client, model, "blue");
//		ForceClientSkin(client, headModel, "blue");
		break;
	}
	// don't ever use a default skin in teamplay, it would just waste memory
	// however bots will always join a team but they spawn in as spectator
	if ( g_gametype.integer >= GT_TEAM && team == TEAM_SPECTATOR) {
		ForceClientSkin(client, model, "red");
//		ForceClientSkin(client, headModel, "red");
	}
*/

// STONELANCE
	// rim
	Q_strncpyz( rim, Info_ValueForKey (userinfo, "rim"), sizeof( rim ) );

	// plate
	Q_strncpyz( plate, Info_ValueForKey (userinfo, "plate"), sizeof( plate ) );
// END

#ifdef MISSIONPACK
	if (g_gametype.integer >= GT_TEAM && !(ent->r.svFlags & SVF_BOT)) {
		client->pers.teamInfo = qtrue;
	} else {
		s = Info_ValueForKey( userinfo, "teamoverlay" );
		if ( ! *s || atoi( s ) != 0 ) {
			client->pers.teamInfo = qtrue;
		} else {
			client->pers.teamInfo = qfalse;
		}
	}
#else
	// teamInfo
	s = Info_ValueForKey( userinfo, "teamoverlay" );
	if ( ! *s || atoi( s ) != 0 ) {
		client->pers.teamInfo = qtrue;
	} else {
		client->pers.teamInfo = qfalse;
	}
#endif

// STONELANCE
	// UPDATE: enable this
/*
	s = Info_ValueForKey( userinfo, "cg_autodrop" );
	if ( ! *s || atoi( s ) != 0 ) {
		client->pers.autoDrop = qtrue;
	} else {
		client->pers.autoDrop = qfalse;
	}
*/

	s = Info_ValueForKey( userinfo, "cg_controlMode" );
	if ( *s ) {
		client->pers.controlMode = atoi( s );
	}

	s = Info_ValueForKey( userinfo, "cg_manualShift" );
	if ( *s ) {
		client->pers.manualShift = atoi( s );
	}
// END

	/*
	s = Info_ValueForKey( userinfo, "cg_pmove_fixed" );
	if ( !*s || atoi( s ) == 0 ) {
		client->pers.pmoveFixed = qfalse;
	}
	else {
		client->pers.pmoveFixed = qtrue;
	}
	*/

	// team task (0 = none, 1 = offence, 2 = defence)
	teamTask = atoi(Info_ValueForKey(userinfo, "teamtask"));
	// team Leader (1 = leader, 0 is normal player)
	teamLeader = client->sess.teamLeader;

	// colors
	Q_strncpyz(c1, Info_ValueForKey( userinfo, "color1" ), sizeof( c1 ));
	Q_strncpyz(c2, Info_ValueForKey( userinfo, "color2" ), sizeof( c2 ));

	Q_strncpyz(redTeam, Info_ValueForKey( userinfo, "g_redteam" ), sizeof( redTeam ));
	Q_strncpyz(blueTeam, Info_ValueForKey( userinfo, "g_blueteam" ), sizeof( blueTeam ));
// STONELANCE - UPDATE: need to add names for green and yellow teams?
	
	// send over a subset of the userinfo keys so other clients can
	// print scoreboards, display models, and play custom sounds
	if (ent->r.svFlags & SVF_BOT)
	{
// STONELANCE - UPDATE: change the userinfo string for bots?
		s = va("n\\%s\\t\\%i\\model\\%s\\hmodel\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\skill\\%s\\tt\\%d\\tl\\%d",
			client->pers.netname, client->sess.sessionTeam, model, headModel, c1, c2,
			client->pers.maxHealth, client->sess.wins, client->sess.losses,
			Info_ValueForKey( userinfo, "skill" ), teamTask, teamLeader );
	}
	else
	{
// STONELANCE
		s = va("n\\%s\\t\\%i\\model\\%s\\hmodel\\%s\\rim\\%s\\plate\\%s\\g_redteam\\%s\\g_blueteam\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\cm\\%i\\ms\\%i\\tt\\%d\\tl\\%d",
			client->pers.netname, client->sess.sessionTeam, model, headModel, rim, plate, redTeam, blueTeam, c1, c2, 
			client->pers.maxHealth, client->sess.wins, client->sess.losses, 
			client->pers.controlMode, client->pers.manualShift, teamTask, teamLeader);
/*
		s = va("n\\%s\\t\\%i\\model\\%s\\hmodel\\%s\\g_redteam\\%s\\g_blueteam\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\tt\\%d\\tl\\%d",
			client->pers.netname, client->sess.sessionTeam, model, headModel, redTeam, blueTeam, c1, c2, 
			client->pers.maxHealth, client->sess.wins, client->sess.losses, teamTask, teamLeader);
*/
// END
	}

	trap_SetConfigstring( CS_PLAYERS+clientNum, s );

	// this is not the userinfo, more like the configstring actually
	G_LogPrintf( "ClientUserinfoChanged: %i %s\n", clientNum, s );
}


/*
===========
ClientConnect

Called when a player begins connecting to the server.
Called again for every map change or tournement restart.

The session information will be valid after exit.

Return NULL if the client should be allowed, otherwise return
a string with the reason for denial.

Otherwise, the client will be sent the current gamestate
and will eventually get to ClientBegin.

firstTime will be qtrue the very first time a client connects
to the server machine, but qfalse on map changes and tournement
restarts.
============
*/
char *ClientConnect( int clientNum, qboolean firstTime, qboolean isBot ) {
	char		*value;
//	char		*areabits;
	gclient_t	*client;
	char		userinfo[MAX_INFO_STRING];
	gentity_t	*ent;

	ent = &g_entities[ clientNum ];

	trap_GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );

 	// IP filtering
 	// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=500
 	// recommanding PB based IP / GUID banning, the builtin system is pretty limited
 	// check to see if they are on the banned IP list
	value = Info_ValueForKey (userinfo, "ip");
	if ( G_FilterPacket( value ) ) {
		return "You are banned from this server.";
	}

  // we don't check password for bots and local client
  // NOTE: local client <-> "ip" "localhost"
  //   this means this client is not running in our current process
	if ( !isBot && (strcmp(value, "localhost") != 0)) {
		// check for a password
		value = Info_ValueForKey (userinfo, "password");
		if ( g_password.string[0] && Q_stricmp( g_password.string, "none" ) &&
			strcmp( g_password.string, value) != 0) {
			return "Invalid password";
		}
	}
	// if a player reconnects quickly after a disconnect, the client disconnect may never be called, thus flag can get lost in the ether
	if (ent->inuse) {
		G_LogPrintf("Forcing disconnect on active client: %i\n", clientNum);
		// so lets just fix up anything that should happen on a disconnect
		ClientDisconnect(clientNum);
	}
	// they can connect
	ent->client = level.clients + clientNum;
	client = ent->client;

//	areabits = client->areabits;

	memset( client, 0, sizeof(*client) );

	client->pers.connected = CON_CONNECTING;

	// check for local client
	value = Info_ValueForKey( userinfo, "ip" );
	if ( !strcmp( value, "localhost" ) ) {
		client->pers.localClient = qtrue;
	}

// STONELANCE
	// FIXME: dont need this anymore?
/*
	if (isRallyRace() && client->sess.sessionTeam == TEAM_SPECTATOR
		&& !client->sess.spectatorWilling){
		if (level.startRaceTime){
			Com_Printf("ClientConnect: race start, spectator\n");
			client->sess.sessionTeam = TEAM_SPECTATOR;
		}
		else if ( g_gametype.integer >= GT_TEAM ) {
			Com_Printf("ClientConnect: team pick\n");
			client->sess.sessionTeam = PickTeam( -1 );
			BroadcastTeamChange( client, -1 );
		}
		else {
			Com_Printf("ClientConnect: team free\n");
			client->sess.sessionTeam = TEAM_FREE;
		}
	}
*/
// END

	if( isBot ) {
		ent->r.svFlags |= SVF_BOT;
		ent->inuse = qtrue;
		if( !G_BotConnect( clientNum, !firstTime ) ) {
			return "BotConnectfailed";
		}
	}

	// read or initialize the session data
	if ( firstTime || level.newSession ) {
		G_InitSessionData( client, userinfo );
	}
	G_ReadSessionData( client );

	// get and distribute relevant parameters
	G_LogPrintf( "ClientConnect: %i\n", clientNum );
	ClientUserinfoChanged( clientNum );

	// don't do the "xxx connected" messages if they were caried over from previous level
	if ( firstTime ) {
		trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " connected\n\"", client->pers.netname) );
	}

	if ( g_gametype.integer >= GT_TEAM &&
		client->sess.sessionTeam != TEAM_SPECTATOR ) {
		BroadcastTeamChange( client, -1 );
	}

	// count current clients and rank for scoreboard
	CalculateRanks();

	// for statistics
//	client->areabits = areabits;
//	if ( !client->areabits )
//		client->areabits = G_Alloc( (trap_AAS_PointReachabilityAreaIndex( NULL ) + 7) / 8 );

	return NULL;
}

/*
===========
ClientBegin

called when a client has finished connecting, and is ready
to be placed into the level.  This will happen every level load,
and on transition between teams, but doesn't happen on respawns
============
*/
void ClientBegin( int clientNum ) {
	gentity_t	*ent;
	gclient_t	*client;
	int			flags;

	ent = g_entities + clientNum;

	client = level.clients + clientNum;

// STONELANCE
	// Make sure that clients that were not fully connected when the
	// race was started will spawn as spectators
	if ((isRallyRace() || g_gametype.integer == GT_DERBY) && level.startRaceTime &&
		client->sess.sessionTeam != TEAM_SPECTATOR && !isRaceObserver( clientNum ) &&
		!client->finishRaceTime ){

		SetTeam(ent, "racerSpectator");
		return;
	}
//	trap_SendServerCommand( -1, va("raceTime %i", level.startRaceTime) );

	client->buttons = 0;
	client->oldbuttons = 0;
// END

	if ( ent->r.linked ) {
		trap_UnlinkEntity( ent );
	}
	G_InitGentity( ent );
	ent->touch = 0;
	ent->pain = 0;
	ent->client = client;

	client->pers.connected = CON_CONNECTED;
	client->pers.enterTime = level.time;
	client->pers.teamState.state = TEAM_BEGIN;

	// save eflags around this, because changing teams will
	// cause this to happen with a valid entity, and we
	// want to make sure the teleport bit is set right
	// so the viewpoint doesn't interpolate through the
	// world to the new position
	flags = client->ps.eFlags;
	memset( &client->ps, 0, sizeof( client->ps ) );
	client->ps.eFlags = flags;

	// locate ent at a spawn point
	ClientSpawn( ent );

// STONELANCE
	ent->ready = qfalse;
	if ( isRallyRace() && !level.startRaceTime )
	{
		ent->number = 1;
		ent->currentLap = 1;
		ent->client->finishRaceTime = 0;
		ent->updateTime = level.time + 1000;
		ent->client->ps.stats[STAT_DAMAGE_DEALT] = 0;
		ent->client->ps.stats[STAT_DAMAGE_TAKEN] = 0;
		ent->client->ps.stats[STAT_NEXT_CHECKPOINT] = ent->number;
	}

	ent->raceObserver = qfalse;
// END

// STONELANCE
/*
	if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
		if ( g_gametype.integer != GT_TOURNAMENT  ) {
			trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " entered the game\n\"", client->pers.netname) );
		}
	}
*/
// END
	G_LogPrintf( "ClientBegin: %i\n", clientNum );

	// count current clients and rank for scoreboard
	CalculateRanks();
}

/*
===========
ClientSpawn

Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn(gentity_t *ent) {
	int		index;
	vec3_t	spawn_origin, spawn_angles;
	gclient_t	*client;
	int		i;
	clientPersistant_t	saved;
	clientSession_t		savedSess;
	int		persistant[MAX_PERSISTANT];
	gentity_t	*spawnPoint;
	gentity_t *tent;
	int		flags;
	int		savedPing;
//	char	*savedAreaBits;
	int		accuracy_hits, accuracy_shots;
	int		eventSequence;
	char	userinfo[MAX_INFO_STRING];
// STONELANCE
	int		savedDamageTaken;
	int		savedDamageDealt;
	gentity_t	*savedCarPoints[4];
	vec3_t	origin, forward;
// END

	index = ent - g_entities;
	client = ent->client;

	VectorClear(spawn_origin);

	// find a spawn point
	// do it before setting health back up, so farthest
	// ranging doesn't count this client
// STONELANCE
//	if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
	if ( client->sess.sessionTeam == TEAM_SPECTATOR || isRaceObserver( ent->s.number ) ) {
		spawnPoint = NULL;
		if ( client->sess.spectatorState == SPECTATOR_OBSERVE ) {
			int clientNum;

			clientNum = client->sess.spectatorClient;

			// team follow1 and team follow2 go to whatever clients are playing
			if ( clientNum == -1 ) {
				clientNum = level.follow1;
			} else if ( clientNum == -2 ) {
				clientNum = level.follow2;
			}

			if( clientNum >= 0)
				spawnPoint = FindBestObserverSpot(ent, &g_entities[clientNum], spawn_origin, spawn_angles);
		}
		if (!spawnPoint)
// END
			spawnPoint = SelectSpectatorSpawnPoint ( 
						spawn_origin, spawn_angles);
	} else if (g_gametype.integer >= GT_CTF ) {
		// all base oriented team games use the CTF spawn points
		spawnPoint = SelectCTFSpawnPoint ( 
						client->sess.sessionTeam, 
						client->pers.teamState.state, 
						spawn_origin, spawn_angles,
						!!(ent->r.svFlags & SVF_BOT));
	}
	else
	{
// STONELANCE
		if (isRallyRace()) {
			// respawn at the grid if the race just started to stop people from
			// killing themselves inorder to get ahead at the beginning
			if ( level.startRaceTime && level.time - level.startRaceTime > 1000 )
				spawnPoint = SelectLastMarkerForSpawn(ent, spawn_origin, spawn_angles, !!(ent->r.svFlags & SVF_BOT));
			else
				spawnPoint = SelectGridPositionSpawn(ent, spawn_origin, spawn_angles, !!(ent->r.svFlags & SVF_BOT));

			if (g_trackReversed.integer && level.trackIsReversable){
				spawn_angles[YAW] += 180;
			}
		} else
// END
		// the first spawn should be at a good looking spot
		if ( !client->pers.initialSpawn && client->pers.localClient )
		{
			client->pers.initialSpawn = qtrue;
			spawnPoint = SelectInitialSpawnPoint(spawn_origin, spawn_angles,
							     !!(ent->r.svFlags & SVF_BOT));
		}
		else
		{
			// don't spawn near existing origin if possible
			spawnPoint = SelectSpawnPoint ( 
				client->ps.origin, 
				spawn_origin, spawn_angles, !!(ent->r.svFlags & SVF_BOT));
		}
	}
	client->pers.teamState.state = TEAM_ACTIVE;

	// always clear the kamikaze flag
	ent->s.eFlags &= ~EF_KAMIKAZE;

	// toggle the teleport bit so the client knows to not lerp
	// and never clear the voted flag
	flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT | EF_VOTED | EF_TEAMVOTED);
	flags ^= EF_TELEPORT_BIT;

	// clear everything but the persistant data

	saved = client->pers;
	savedSess = client->sess;
	savedPing = client->ps.ping;
// STONELANCE
	savedDamageDealt = client->ps.stats[STAT_DAMAGE_DEALT];
	savedDamageTaken = client->ps.stats[STAT_DAMAGE_TAKEN];
// END
//	savedAreaBits = client->areabits;
	accuracy_hits = client->accuracy_hits;
	accuracy_shots = client->accuracy_shots;
	for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
		persistant[i] = client->ps.persistant[i];
	}
	eventSequence = client->ps.eventSequence;

// STONELANCE
	savedCarPoints[0] = client->carPoints[0];
	savedCarPoints[1] = client->carPoints[1];
	savedCarPoints[2] = client->carPoints[2];
	savedCarPoints[3] = client->carPoints[3];
/*
	for (i = 0; i < FIRST_FRAME_POINT; i++){
		if ( client->carPoints[i] ){
//			Com_Printf("Freeing wheel entities\n");
			G_FreeEntity( client->carPoints[i] );
		}
	}
*/
// END

	Com_Memset (client, 0, sizeof(*client));

	client->pers = saved;
	client->sess = savedSess;
	client->ps.ping = savedPing;
// STONELANCE
	client->carPoints[0] = savedCarPoints[0];
	client->carPoints[1] = savedCarPoints[1];
	client->carPoints[2] = savedCarPoints[2];
	client->carPoints[3] = savedCarPoints[3];
	client->ps.stats[STAT_DAMAGE_DEALT] = savedDamageDealt;
	client->ps.stats[STAT_DAMAGE_TAKEN] = savedDamageTaken;
	client->ps.stats[STAT_NEXT_CHECKPOINT] = ent->number;
// END
//	client->areabits = savedAreaBits;
	client->accuracy_hits = accuracy_hits;
	client->accuracy_shots = accuracy_shots;
	client->lastkilled_client = -1;

	for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
		client->ps.persistant[i] = persistant[i];
	}
	client->ps.eventSequence = eventSequence;
	// increment the spawncount so the client will detect the respawn
	client->ps.persistant[PERS_SPAWN_COUNT]++;
	client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;

	client->airOutTime = level.time + 12000;

	trap_GetUserinfo( index, userinfo, sizeof(userinfo) );
	// set max health
	client->pers.maxHealth = atoi( Info_ValueForKey( userinfo, "handicap" ) );
	if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
		client->pers.maxHealth = 100;
	}
	// clear entity values
	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
	client->ps.eFlags = flags;

	ent->s.groundEntityNum = ENTITYNUM_NONE;
	ent->client = &level.clients[index];
	ent->takedamage = qtrue;
	ent->inuse = qtrue;
	ent->classname = "player";
	ent->r.contents = CONTENTS_BODY;
	ent->clipmask = MASK_PLAYERSOLID;
	ent->die = player_die;
	ent->waterlevel = 0;
	ent->watertype = 0;
	ent->flags = 0;
	
	VectorCopy (playerMins, ent->r.mins);
	VectorCopy (playerMaxs, ent->r.maxs);

// STONELANCE
	client->ps.pm_flags |= SVF_CAPSULE;
// END

	client->ps.clientNum = index;

// STONELANCE (dont give machinegun on spawn in races)
	if (!isRallyRace()/* TEMP DERBY && g_gametype.integer != GT_DERBY */){
		client->ps.stats[STAT_WEAPONS] = ( 1 << WP_MACHINEGUN );
		if ( g_gametype.integer == GT_TEAM ) {
			client->ps.ammo[WP_MACHINEGUN] = 50;
		} else {
			client->ps.ammo[WP_MACHINEGUN] = 100;
		}
	}

	if (!isRallyNonDMRace()/* TEMP DERBY && g_gametype.integer != GT_DERBY*/){
		client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_GAUNTLET );
	}
	else {
		client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_GAUNTLET );
	}

/*
	client->ps.stats[STAT_WEAPONS] = ( 1 << WP_MACHINEGUN );
	if ( g_gametype.integer == GT_TEAM ) {
		client->ps.ammo[WP_MACHINEGUN] = 50;
	} else {
		client->ps.ammo[WP_MACHINEGUN] = 100;
	}

	client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_GAUNTLET );
*/
// END

	client->ps.ammo[WP_GAUNTLET] = -1;
// STONELANCE
//	client->ps.ammo[WP_GRAPPLING_HOOK] = -1;
// END

	// health will count down towards max_health
	ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] + 25;

	G_SetOrigin( ent, spawn_origin );
	VectorCopy( spawn_origin, client->ps.origin );

	// the respawned flag will be cleared after the attack and jump keys come up
	client->ps.pm_flags |= PMF_RESPAWNED;

	trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
	SetClientViewAngle( ent, spawn_angles );

// STONELANCE
	ent->client->pers.cmd.buttons = 0;

	client->frameNum = 0;
	client->pmoveTime = 0;

//	PM_InitializeVehicle(&client->car, client->ps.origin, spawn_angles /*client->ps.viewangles*/, vec3_origin, car_frontweight_dist.value );
	client->car.initializeOnNextMove = qtrue;

	if ( !ent->frontBounds )
		ent->frontBounds = G_Spawn();
	if ( !ent->rearBounds )
		ent->rearBounds = G_Spawn();

//	ent->r.ownerNum = client->ps.clientNum;

	VectorCopy (playerMins, ent->frontBounds->r.mins);
	VectorCopy (playerMaxs, ent->frontBounds->r.maxs);
	if ( client->sess.sessionTeam != TEAM_SPECTATOR && !isRaceObserver( ent->s.number ) ) 
		ent->frontBounds->r.contents = CONTENTS_BODY;
	else
		ent->frontBounds->r.contents = 0;
	ent->frontBounds->r.svFlags = SVF_NOCLIENT;
	ent->frontBounds->flags = FL_EXTRA_BBOX;
	ent->frontBounds->r.ownerNum = client->ps.clientNum;

	VectorCopy (playerMins, ent->rearBounds->r.mins);
	VectorCopy (playerMaxs, ent->rearBounds->r.maxs);
	if ( client->sess.sessionTeam != TEAM_SPECTATOR && !isRaceObserver( ent->s.number ) ) 
		ent->rearBounds->r.contents = CONTENTS_BODY;
	else
		ent->rearBounds->r.contents = 0;
	ent->rearBounds->r.svFlags = SVF_NOCLIENT;
	ent->rearBounds->flags = FL_EXTRA_BBOX;
	ent->rearBounds->r.ownerNum = client->ps.clientNum;

	AngleVectors(spawn_angles, forward, NULL, NULL);
	VectorMA( client->ps.origin, (CAR_LENGTH - CAR_WIDTH) / 2, forward, origin );
	G_SetOrigin( ent->frontBounds, origin );
// STONELANCE - temp test of capsules
	trap_LinkEntity ( ent->frontBounds );

	VectorMA( client->ps.origin, -(CAR_LENGTH - CAR_WIDTH) / 2, forward, origin );
	G_SetOrigin( ent->rearBounds, origin );
// STONELANCE - temp test of capsules
	trap_LinkEntity ( ent->rearBounds );

	// FIXME: try to get rid of 2
	// carpoints
	for (i = 0; i < FIRST_FRAME_POINT; i++){
		if ( !client->carPoints[i] ) {
			client->carPoints[i] = G_Spawn();
//			Com_Printf("Spawning wheel entities\n");
		}
/*
		if (i == 0 || i == 1)
			client->carPoints[i]->s.modelindex = G_ModelIndex("models/test/sphere02.md3");
		else if (i == 2 || i == 3)
			client->carPoints[i]->s.modelindex = G_ModelIndex("models/test/sphere01.md3");
		else if (i == 4 || i == 5)
			client->carPoints[i]->s.modelindex = G_ModelIndex("models/test/sphere03.md3");
		else if (i == 6 || i == 7)
			client->carPoints[i]->s.modelindex = G_ModelIndex("models/test/sphere04.md3");
		else
			client->carPoints[i]->s.modelindex = G_ModelIndex("models/test/sphere02.md3");
*/
//		client->carPoints[i].r.svFlags = SVF_NOCLIENT;

		client->carPoints[i]->s.otherEntityNum = ent->s.clientNum;
		client->carPoints[i]->s.otherEntityNum2 = i;
		client->carPoints[i]->r.svFlags |= SVF_SINGLECLIENT | SVF_BROADCAST;
		client->carPoints[i]->r.singleClient = ent->s.number;

		client->carPoints[i]->s.eType = ET_AUXENT;
//		trap_LinkEntity(client->carPoints[i]);
	}
// END

	// don't allow full run speed for a bit
	client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
	client->ps.pm_time = 100;

	client->respawnTime = level.time;
	client->inactivityTime = level.time + g_inactivity.integer * 1000;
	client->latched_buttons = 0;

	// set default animations
// STONELANCE
/*
	client->ps.torsoAnim = TORSO_STAND;
	client->ps.legsAnim = LEGS_IDLE;
*/
// END

	if (!level.intermissiontime) {
		if (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
			G_KillBox(ent);
			// force the base weapon up
// STONELANCE
			if (!isRallyRace()/* TEMP DERBY && g_gametype.integer != GT_DERBY*/){
				client->ps.weapon = WP_MACHINEGUN;
			}
			else if (!isRallyNonDMRace()/*TEMP DERBY && g_gametype.integer != GT_DERBY*/){
				client->ps.weapon = WP_GAUNTLET;
			}
			else {
				client->ps.weapon = WP_NONE;
			}

//			client->ps.weapon = WP_MACHINEGUN;
// END
			client->ps.weaponstate = WEAPON_READY;
			// fire the targets of the spawn point
			G_UseTargets(spawnPoint, ent);
			// select the highest weapon number available, after any spawn given items have fired
			client->ps.weapon = 1;

			for (i = WP_NUM_WEAPONS - 1 ; i > 0 ; i--) {
				if (client->ps.stats[STAT_WEAPONS] & (1 << i)) {
					client->ps.weapon = i;
					break;
				}
			}
			// positively link the client, even if the command times are weird
			VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);

			tent = G_TempEntity(ent->client->ps.origin, EV_PLAYER_TELEPORT_IN);
			tent->s.clientNum = ent->s.clientNum;

			trap_LinkEntity (ent);
		}
	} else {
		// move players to intermission
		MoveClientToIntermission(ent);
	}
	// run a client frame to drop exactly to the floor,
	// initialize animations and other things
	client->ps.commandTime = level.time - 100;
	ent->client->pers.cmd.serverTime = level.time;
	ClientThink( ent-g_entities );
	// run the presend to set anything else, follow spectators wait
	// until all clients have been reconnected after map_restart
	if ( ent->client->sess.spectatorState != SPECTATOR_FOLLOW ) {
		ClientEndFrame( ent );
	}

	// clear entity state values
	BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
}


/*
===========
ClientDisconnect

Called when a player drops from the server.
Will not be called between levels.

This should NOT be called directly by any game logic,
call trap_DropClient(), which will call this and do
server system housekeeping.
============
*/
void ClientDisconnect( int clientNum ) {
	gentity_t	*ent;
	gentity_t	*tent;
	int			i;

	// cleanup if we are kicking a bot that
	// hasn't spawned yet
	G_RemoveQueuedBotBegin( clientNum );

	ent = g_entities + clientNum;
	if (!ent->client || ent->client->pers.connected == CON_DISCONNECTED) {
		return;
	}

	// stop any following clients
	for ( i = 0 ; i < level.maxclients ; i++ ) {
		if ( level.clients[i].sess.sessionTeam == TEAM_SPECTATOR
			&& level.clients[i].sess.spectatorState == SPECTATOR_FOLLOW
			&& level.clients[i].sess.spectatorClient == clientNum ) {
			StopFollowing( &g_entities[i] );
		}
	}

	// send effect if they were completely connected
	if ( ent->client->pers.connected == CON_CONNECTED 
		&& ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );
		tent->s.clientNum = ent->s.clientNum;

		// They don't get to take powerups with them!
		// Especially important for stuff like CTF flags
		TossClientItems( ent );
#ifdef MISSIONPACK
		TossClientPersistantPowerups( ent );
		if( g_gametype.integer == GT_HARVESTER ) {
			TossClientCubes( ent );
		}
#endif

	}

	G_LogPrintf( "ClientDisconnect: %i\n", clientNum );

	// if we are playing in tourney mode and losing, give a win to the other player
// STONELANCE
/*
	if ( (g_gametype.integer == GT_TOURNAMENT )
		&& !level.intermissiontime
		&& !level.warmupTime && level.sortedClients[1] == clientNum ) {
		level.clients[ level.sortedClients[0] ].sess.wins++;
		ClientUserinfoChanged( level.sortedClients[0] );
	}

	if( g_gametype.integer == GT_TOURNAMENT &&
		ent->client->sess.sessionTeam == TEAM_FREE &&
		level.intermissiontime ) {

		trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
		level.restarted = qtrue;
		level.changemap = NULL;
		level.intermissiontime = 0;
	}
*/

	if ( ent->frontBounds ){
		G_FreeEntity( ent->frontBounds );
		ent->frontBounds = NULL;
	}
	if ( ent->rearBounds ){
		G_FreeEntity( ent->rearBounds );
		ent->rearBounds = NULL;
	}

	for (i = 0; i < 4; i++){
		if ( ent->client->carPoints[i] ){
			G_FreeEntity( ent->client->carPoints[i] );
			ent->client->carPoints[i] = NULL;
		}
	}
// END

	trap_UnlinkEntity (ent);
	ent->s.modelindex = 0;
	ent->inuse = qfalse;
	ent->classname = "disconnected";
	ent->client->pers.connected = CON_DISCONNECTED;
	ent->client->ps.persistant[PERS_TEAM] = TEAM_FREE;
	ent->client->sess.sessionTeam = TEAM_FREE;

	trap_SetConfigstring( CS_PLAYERS + clientNum, "");

	CalculateRanks();

	if ( ent->r.svFlags & SVF_BOT ) {
		BotAIShutdownClient( clientNum, qfalse );
	}
}