rpg-x2/game/g_active.c

// Copyright (C) 1999-2000 Id Software, Inc.
//

#include "g_local.h"

extern void SP_misc_ammo_station( gentity_t *ent );
extern void ammo_station_finish_spawning ( gentity_t *self );
extern int	borgQueenClientNum;
//extern qboolean BG_BorgTransporting( playerState_t *ps );

static int lastTimedMessage; //TiM - Moved here from g_local.h

/*
==============
TryUse
==============
*/

#define USE_DISTANCE	64.0f
/**
*	Try and use an entity in the world, directly ahead of us
*/
void TryUse( gentity_t *ent )
{
	gentity_t	*target; //, *newent;
	trace_t		trace;
	vec3_t		src, dest, vf;
	clientSession_t *sess;
	
	if(!ent || !ent->client) return;

	sess = &ent->client->sess;

	VectorCopy( ent->r.currentOrigin, src );
	src[2] += ent->client->ps.viewheight * ent->client->pers.pms_height; //TiM - include height offset for tall players

	AngleVectors( ent->client->ps.viewangles, vf, NULL, NULL );

	//extend to find end of use trace
	VectorMA( src, -6, vf, src );//in case we're inside something?
	VectorMA( src, 134, vf, dest );//128+6

	//Trace ahead to find a valid target
	trap_Trace( &trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE );

	if ( trace.fraction == 1.0f || trace.entityNum < 0 )
	{
		//FIXME: Play a failure sound
		return;
	}

	target = &g_entities[trace.entityNum];

	//Check for a use command
	if ( target && target->client )
	{//if a bot, make it follow me, if a teammate, give stuff
		if ( target->client->sess.sessionTeam == sess->sessionTeam )
		{//on my team
//			gitem_t	*regen = BG_FindItemForPowerup( PW_LASER );
//			gitem_t	*invis = BG_FindItemForPowerup( PW_INVIS );

			//switch( sess->sessionClass )
			//{
			//case PC_MEDIC://medic gives regen
			//	break;
			//case PC_TECH://tech gives invisibility
			//	break;
			//}
			//switch( target->client->sess.sessionClass )
			//{
			//case PC_TECH://using tech gives you full ammo
			//	G_Sound(ent, G_SoundIndex("sound/player/suitenergy.wav") );
			//	for ( i = 0 ; i < MAX_WEAPONS ; i++ )
			//	{
			//		ent->client->ps.ammo[i] = Max_Ammo[i];
			//	}
			//	return;
			//	break;
			//}
		}
	}
	else if ( target && target->use && Q_stricmp("func_usable", target->classname) == 0 )
	{//usable brush
		if ( target->team && atoi( target->team ) != 0 )
		{//usable has a team
			if ( atoi( target->team ) != sess->sessionTeam )
			{//not on my team
				//if ( sess->sessionClass != PC_TECH )
				//{//only a tech can use enemy usables
				//	//FIXME: Play a failure sound
				//	return;
				//}

				//TiM - return
				return;
			}
		}
		//FIXME: play sound?
		target->use( target, ent, ent );
		#ifdef G_LUA
		if(target->luaUse)
			LuaHook_G_EntityUse(target->luaUse, target-g_entities, ent-g_entities, ent-g_entities);
		#endif
		return;
	}
	else if ( target && target->use && Q_stricmp("misc_ammo_station", target->classname) == 0 )
	{//ammo station
		if ( sess->sessionTeam )
		{
			if ( target->team )
			{
				if ( atoi( target->team ) != sess->sessionTeam )
				{
					//FIXME: play sound?
					return;
				}
			}
		}
		target->use( target, ent, ent );
		#ifdef G_LUA
		if(target->luaUse)
			LuaHook_G_EntityUse(target->luaUse, target-g_entities, ent-g_entities, ent-g_entities);
		#endif
		return;
	}
	else if ( (target && target->s.number == ENTITYNUM_WORLD) || (target->s.pos.trType == TR_STATIONARY && !(trace.surfaceFlags & SURF_NOIMPACT) && !target->takedamage) )
	{
		//switch( ent->client->sess.sessionClass )
		//{
		//case PC_TECH://tech can place an ammo station
		//	break;
		//}
		//FIXME: play sound
		return;
	}
	//FIXME: Play a failure sound
}

/*
===============
G_DamageFeedback
===============
*/
/**
*	Called just before a snapshot is sent to the given player.
*	Totals up all damage and generates both the player_state_t
*	damage values to that client for pain blends and kicks, and
*	global pain sound events for all clients.
*/
void P_DamageFeedback( gentity_t *player ) {
	gclient_t	*client;
	float	count;
	vec3_t	angles;
	playerState_t *ps;

	client = player->client;
	ps = &client->ps;
	if ( client->ps.pm_type == PM_DEAD ) {
		return;
	}

	// total points of damage shot at the player this frame
	count = client->damage_blood + client->damage_armor;
	if ( count == 0 ) {
		return;		// didn't take any damage
	}

	if ( count > 255 ) {
		count = 255;
	}

	// send the information to the client

	// world damage (falling, slime, etc) uses a special code
	// to make the blend blob centered instead of positional
	if ( client->damage_fromWorld ) {
		ps->damagePitch = 255;
		ps->damageYaw = 255;

		client->damage_fromWorld = qfalse;
	} else {
		vectoangles( client->damage_from, angles );
		ps->damagePitch = angles[PITCH]/360.0 * 256;
		ps->damageYaw = angles[YAW]/360.0 * 256;
	}

	// play an apropriate pain sound
	if ( (level.time > player->pain_debounce_time) && !(player->flags & FL_GODMODE) ) {
		player->pain_debounce_time = level.time + 700;
		G_AddEvent( player, EV_PAIN, player->health );
		ps->damageEvent++;
	}

	ps->damageCount = client->damage_blood;
	if (ps->damageCount > 255)
	{
		ps->damageCount = 255;
	}

	ps->damageShieldCount = client->damage_armor;
	if (ps->damageShieldCount > 255)
	{
		ps->damageShieldCount = 255;
	}

	//
	// clear totals
	//
	client->damage_blood = 0;
	client->damage_armor = 0;
	client->damage_knockback = 0;
}



/*
=============
P_WorldEffects
=============
*/
/**
*	Check for lava / slime contents and drowning
*/
void P_WorldEffects( gentity_t *ent ) {
	//qboolean	envirosuit;
	int			waterlevel;

	if ( ent->client->noclip ) {
		ent->client->airOutTime = level.time + 12000;	// don't need air
		return;
	}

	waterlevel = ent->waterlevel;

	//envirosuit = ent->client->ps.powerups[PW_BOLTON] > level.time;

	//
	// check for drowning
	//
	if ( waterlevel == 3 && !(ent->watertype&CONTENTS_LADDER)) {
		// envirosuit give air, techs can't drown
		if ( /*envirosuit ||*/ g_classData[ent->client->sess.sessionClass].isMarine/*ent->client->sess.sessionClass == PC_ALPHAOMEGA22*/ ) {
			ent->client->airOutTime = level.time + 10000;
		}

		// if out of air, start drowning
		if ( ent->client->airOutTime < level.time) {
			// drown!
			ent->client->airOutTime += 1000;
			if ( ent->health > 1 ) { //TiM : used to be 0, but to fix red's medic code
				// take more damage the longer underwater
				ent->damage += 2;
				if (ent->damage > 15)
					ent->damage = 15;

				// play a gurp sound instead of a normal pain sound
				if (ent->health <= ent->damage) {
					G_Sound(ent, G_SoundIndex("*drown.wav"));
				} else if (rand()&1) {
					G_Sound(ent, G_SoundIndex("sound/player/gurp1.wav"));
				} else {
					G_Sound(ent, G_SoundIndex("sound/player/gurp2.wav"));
				}

				// don't play a normal pain sound
				ent->pain_debounce_time = level.time + 200;

				G_Damage (ent, NULL, NULL, NULL, NULL,
					ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
			}
		}
	} else {
		ent->client->airOutTime = level.time + 12000;
		ent->damage = 2;
	}

	//
	// check for sizzle damage (move to pmove?)
	//
	if (waterlevel &&
		(ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
		if (ent->health > 0
			&& ent->pain_debounce_time < level.time	) {

/*			if ( envirosuit ) {
				G_AddEvent( ent, EV_POWERUP_BATTLESUIT, 0 );
			} else {*/
				if (ent->watertype & CONTENTS_LAVA) {
					G_Damage (ent, NULL, NULL, NULL, NULL,
						30*waterlevel, 0, MOD_LAVA);
				}

				if (ent->watertype & CONTENTS_SLIME) {
					G_Damage (ent, NULL, NULL, NULL, NULL,
						10*waterlevel, 0, MOD_SLIME);
				}
			//}
		}
	}
}



/*
===============
G_SetClientSound
===============
*/
void G_SetClientSound( gentity_t *ent )
{	// 3/28/00 kef -- this is dumb.
	if (ent->waterlevel && (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) )
		ent->s.loopSound = level.snd_fry;
	else
		ent->s.loopSound = 0;
}



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

/*
==============
ClientImpacts
==============
*/
void ClientImpacts( gentity_t *ent, pmove_t *pm ) {
	int		i, j;
	trace_t	trace;
	gentity_t	*other;

	memset( &trace, 0, sizeof( trace ) );
	for (i=0 ; i<pm->numtouch ; i++) {
		for (j=0 ; j<i ; j++) {
			if (pm->touchents[j] == pm->touchents[i] ) {
				break;
			}
		}
		if (j != i) {
			continue;	// duplicated
		}
		other = &g_entities[ pm->touchents[i] ];

		if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
			ent->touch( ent, other, &trace );
		}

		if ( !other->touch ) {
			continue;
		}

		other->touch( other, ent, &trace );
	}

}

/*
============
G_TouchTriggers
============
*/
/**
*	Find all trigger entities that ent's current position touches.
*	Spectators will only interact with teleporters.
*/
void	G_TouchTriggers( gentity_t *ent ) {
	int			i, num;
	int			touch[MAX_GENTITIES];
	gentity_t	*hit;
	trace_t		trace;
	vec3_t		mins, maxs;
	static vec3_t	range = { 40, 40, 52 };
	playerState_t *ps;

	if ( !ent || !ent->client ) {
		return;
	}

	ps = &ent->client->ps;

	// dead clients don't activate triggers!
	if ( ps->stats[STAT_HEALTH] <= 0 ) {
		return;
	}

	VectorSubtract( ps->origin, range, mins );
	VectorAdd( ps->origin, range, maxs );

	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

	// can't use ent->absmin, because that has a one unit pad
	VectorAdd( ps->origin, ent->r.mins, mins );
	VectorAdd( ps->origin, ent->r.maxs, maxs );

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

		#ifdef G_LUA
		if(hit->luaTouch)
		{
			LuaHook_G_EntityTouch(hit->luaTouch, hit->s.number, ent->s.number);
		}
		#endif

		if ( !hit->touch && !ent->touch ) {
			continue;
		}
		if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) {
			continue;
		}

		// ignore most entities if a spectator
		if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR /*|| (ps->eFlags&EF_ELIMINATED)*/ )
		{
			//RPG-X: J2J - No clip spectating doesnt need to use transporter entities or door triggers!
//			if( rpg_noclipspectating.integer == 1 )
//				continue;
				
			// this is ugly but adding a new ET_? type will
			// most likely cause network incompatibilities
			if ( hit->s.eType != ET_TELEPORT_TRIGGER &&	hit->touch != Touch_DoorTrigger) 
			{
				continue;
			}
		}

		// use seperate code for determining if an item is picked up
		// so you don't have to actually contact its bounding box
		if ( hit->s.eType == ET_ITEM ) {
			if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
				continue;
			}
		} else {
			if ( !trap_EntityContact( mins, maxs, hit ) ) {
				continue;
			}
		}

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

		if ( hit->touch ) {
			hit->touch (hit, ent, &trace);
		}

		if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
			ent->touch( ent, hit, &trace );
		}
	}
}

/*
=================
SpectatorThink
=================
*/
void SpectatorThink( gentity_t *ent, usercmd_t *ucmd ) {
	pmove_t	pm;
	gclient_t	*client;

	client = ent->client;

	if ( client->sess.spectatorState != SPECTATOR_FOLLOW ) {
		client->ps.pm_type = PM_SPECTATOR;
		client->ps.speed = 400;	// faster than normal

		// set up for pmove
		memset (&pm, 0, sizeof(pm));
		pm.ps = &client->ps;
		pm.cmd = *ucmd;
		pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;	// spectators can fly through bodies
		pm.trace = trap_Trace;
		pm.pointcontents = trap_PointContents;

		// perform a pmove
		Pmove (&pm);

		// save results of pmove
		VectorCopy( client->ps.origin, ent->s.origin );

		G_TouchTriggers( ent );
		trap_UnlinkEntity( ent );
	}

	client->oldbuttons = client->buttons;
	client->buttons = ucmd->buttons;

	// attack button cycles through spectators
	if ( ( client->buttons & BUTTON_ATTACK ) && ! ( client->oldbuttons & BUTTON_ATTACK ) ) {
		Cmd_FollowCycle_f( ent, 1 );
	}
	else if ( ( client->buttons & BUTTON_ALT_ATTACK ) && ! ( client->oldbuttons & BUTTON_ALT_ATTACK ) )
	{
		if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) {
			StopFollowing( ent );
		}
	}
}



/*
=================
ClientInactivityTimer
=================
*/
/**
*	Returns qfalse if the client is dropped
*/
qboolean ClientInactivityTimer( gclient_t *client )
{
	usercmd_t *cmd = &client->pers.cmd;

	if ( ! g_inactivity.integer )
	{
		// give everyone some time, so if the operator sets g_inactivity during
		// gameplay, everyone isn't kicked
		client->inactivityTime = level.time + 60 * 1000;
		client->inactivityWarning = qfalse;
	}
	else if (	cmd->forwardmove ||
				cmd->rightmove ||
				cmd->upmove ||
				(cmd->buttons & BUTTON_ATTACK) ||
				(cmd->buttons & BUTTON_ALT_ATTACK) )
	{
		client->inactivityTime = level.time + g_inactivity.integer * 1000;
		client->inactivityWarning = qfalse;
	}
	else if ( !client->pers.localClient )
	{
		if ( level.time > client->inactivityTime )
		{
			trap_DropClient( client - level.clients, "Dropped due to inactivity" );
			return qfalse;
		}
		if ( level.time > client->inactivityTime - 10000 && !client->inactivityWarning )
		{
			client->inactivityWarning = qtrue;
			trap_SendServerCommand( client - level.clients, "cp \"Ten seconds until inactivity drop!\n\"" );
		}
	}
	return qtrue;
}


/*
==================
TimedMessage

RPG-X - RedTechie: Returns the message requested.
If the message is blank go to next. (Based off of SFEFMOD)

TiM: Huh... O_o.  Damn Red, you're right.  If the admin
puts in values, but not in a consistent consecutive order,
we'll get some mighty painful errors. >.<

I guess what we really need is a for loop that goes
thru, and checks to see if each and every CVAR has a value
currently in it....
==================
*/

//First off let's store the CVAR data in a local array.
//This'll let us perform for loop operations on it.
//Sigh, I wish I knew a quick way to convert variable names
//to strings.  Then this wouldn't be necessary O_o
static char *rpg_message[] = { rpg_message1.string,
							   rpg_message2.string,
							   rpg_message3.string,
							   rpg_message4.string,
							   rpg_message5.string,
							   rpg_message6.string,
							   rpg_message7.string,
							   rpg_message8.string,
							   rpg_message9.string,
							   rpg_message10.string };
/**
*	\author Ubergames
*/
char *TimedMessage( void ){
	int i = lastTimedMessage;

	while ( 1 ) { //Okay, start from the number we want, and loop thru all of them
		if ( i >= 11 ) { //reset loop
			i = 1;
		}

		if ( strlen( rpg_message[i-1] ) >= 1 ) { //i-1 coz arrays start @ 0, but we started @ 1
			lastTimedMessage = i;

			return rpg_message[i-1]; //return the string
		}
	
		if ( i == lastTimedMessage - 1 ) { //okay, we've obviously gone thru the whole loop and come up with nothing. So screw it.
			return NULL;
		}

		//TiM: Cheap hack to stop it freezing if string0 is empty.  THe above condition don't work here
		if ( ((i == 1 && lastTimedMessage == 1) && !strlen( rpg_message[i-1] )) ) {
			return NULL;
		}

		i++;
	}

	//TiM: Hopefully it'll never reach here, but we have this anyway to shut the compiler up
	return "^1RPG-X ERROR: No messages to display";
	

/*
	switch( Msg ){
		case 1:
			if(strlen(rpg_message1.string) >= 1){
				lastTimedMessage = 1;
				return rpg_message1.string;
			}else{
				return TimedMessage( 2 );
			}
			break;

		case 2:
			if(strlen(rpg_message2.string) >= 1){
				lastTimedMessage = 2;
				return rpg_message2.string;
			}else{
				return TimedMessage( 3 );
			}
			break;

		case 3:
			if(strlen(rpg_message3.string) >= 1){
				lastTimedMessage = 3;
				return rpg_message3.string;
			}else{
				return TimedMessage( 4 );
			}
			break;

		case 4:
			if(strlen(rpg_message4.string) >= 1){
				lastTimedMessage = 4;
				return rpg_message4.string;
			}else{
				return TimedMessage( 5 );
			}
			break;

		case 5:
			if(strlen(rpg_message5.string) >= 1){
				lastTimedMessage = 5;
				return rpg_message5.string;
			}else{
				return TimedMessage( 6 );
			}
			break;

		case 6:
			if(strlen(rpg_message6.string) >= 1){
				lastTimedMessage = 6;
				return rpg_message6.string;
			}else{
				return TimedMessage( 7 );
			}
			break;

		case 7:
			if(strlen(rpg_message7.string) >= 1){
				lastTimedMessage = 7;
				return rpg_message7.string;
			}else{
				return TimedMessage( 8 );
			}
			break;

		case 8:
			if(strlen(rpg_message8.string) >= 1){
				lastTimedMessage = 8;
				return rpg_message8.string;
			}else{
				return TimedMessage( 9 );
			}
			break;

		case 9:
			if(strlen(rpg_message9.string) >= 1){
				lastTimedMessage = 9;
				return rpg_message9.string;
			}else{
				return TimedMessage( 10 );
			}
			break;

		case 10:
			if(strlen(rpg_message10.string) >= 1){
				lastTimedMessage = 0; //Start over again
				return rpg_message10.string;
			}else{
				return TimedMessage( 1 );
			}
			break;

		default:
			return "^1RPG-X ERROR: No messages to display";
			break;
	}*/
}


/*
==================
ClientTimerActions
==================
*/
/**
*	Actions that happen once a second
*/
void ClientTimerActions( gentity_t *ent, int msec ) {
	gclient_t	*client;
	char		*message;
	float		messageTime;

	client = ent->client;
	client->timeResidual += msec;

	//RPG-X - RedTechie: Heavily Modifyed Message system (Based off of phenix's old code)
	/*if ( level.time >= (level.message + (rpg_timedmessagetime.integer * 60000)) ) {
		level.message = level.time;
		trap_SendServerCommand( -1, va("cp \"%s\n\"", rpg_timedmessage.string) );
		//trap_SendServerCommand( -1, va( "print \"%s\n\"", rpg_timedmessage ) );
	}*/
	if( rpg_timedmessagetime.value ){
		//Make sure its not less then one //TiM: Well... we can have under 1, just not toooo far under 1
		
		//TiM : Init/reset TimedMessage's value
		if ( lastTimedMessage <= 0 || lastTimedMessage > 10 ) {
			lastTimedMessage = 1;
		}

		if(rpg_timedmessagetime.value < 0.2) { //1
			messageTime = 0.2;
		}else{
			messageTime = rpg_timedmessagetime.value;
		}

		if (level.time > (level.message + (messageTime * 60000)) ) {
			level.message = level.time;
			
			//TiM - There.  So with this working in conjunction with that reset
			//code above, this should be more efficient. :)
			message = TimedMessage(); //Since we're working with a gloabl scope variable, there's no need for this thing to have parameters:)
			lastTimedMessage++;

			/*//Decide what timed message to display
			if( lastTimedMessage && lastTimedMessage != 0 ){
				//A message has been displayed
				if(lastTimedMessage == 1){
					//Display message 2
					message = TimedMessage( 2 );
				}else if(lastTimedMessage == 2){
					//Display message 3
					message = TimedMessage( 3 );
				}else if(lastTimedMessage == 3){
					//Display message 4
					message = TimedMessage( 4 );
				}else if(lastTimedMessage == 4){
					//Display message 5
					message = TimedMessage( 5 );
				}else if(lastTimedMessage == 5){
					//Display message 6
					message = TimedMessage( 6 );
				}else if(lastTimedMessage == 6){
					//Display message 7
					message = TimedMessage( 7 );
				}else if(lastTimedMessage == 7){
					//Display message 8
					message = TimedMessage( 8 );
				}else if(lastTimedMessage == 8){
					//Display message 9
					message = TimedMessage( 9 );
				}else if(lastTimedMessage == 9){
					//Display message 10
					message = TimedMessage( 10 );
				}else{
					//BAD
					message = "^1RPG-X ERROR: lastTimedMessage not set correctly.";
				}
			}else{
				//A message hasnt been displayed yet
				message = TimedMessage( 1 );
			}*/
			
			//Alright send the message now
			if ( message != NULL ) {
				trap_SendServerCommand( -1, va("cp \"%s\n\"", message) );  //Shows the message on their main screen
			}

			//trap_SendServerCommand( -1, va("print \"\n \n%s \n\"", message));  //Shows the message in console
		}
	}



	while ( client->timeResidual >= 1000 ) {
		client->timeResidual -= 1000;

		// regenerate
		//TiM - removed so we can use the REGEN powerup elsewhere
		/*if ( client->ps.powerups[PW_LASER] )
		{
			if ( client->sess.sessionClass != PC_NOCLASS && client->sess.sessionClass != PC_BORG && client->sess.sessionClass != PC_ACTIONHERO )
			{
				if ( ent->health < client->ps.stats[STAT_MAX_HEALTH] )
				{
					ent->health += 2;
					G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
				}
			}
			else if ( ent->health < client->ps.stats[STAT_MAX_HEALTH])
			{
				ent->health += 15;
				if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] * 1.1 )
				{
					ent->health = client->ps.stats[STAT_MAX_HEALTH] * 1.1;
				}
				G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
			}
			else if ( ent->health < client->ps.stats[STAT_MAX_HEALTH] * 2)
			{
				ent->health += 5;
				if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] * 2 )
				{
					ent->health = client->ps.stats[STAT_MAX_HEALTH] * 2;
				}
				G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
			}
		}*/
		/*else if (ent->flags & FL_CLOAK)
		{
			//RPG-X: RedTechie - Health dosnt matter 
			if ( ent->health < 41)
			{
				ent->flags ^= FL_CLOAK;
				ent->client->ps.powerups[PW_INVIS]  = level.time + 1000000000;
			}
		}
		else if (ent->flags & FL_FLY)
		{
			//RPG-X: RedTechie - Health dosnt matter 
			if ( ent->health < 41)
			{
				ent->flags ^= FL_FLY;
				ent->client->ps.powerups[PW_FLIGHT] = level.time + 1000000000;
			}
		}*/
		//else
		//{
			// count down health when over max and not cloaked.
			if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] )
			{
				ent->health--;
			}
		//}

		// THIS USED TO count down armor when over max, more slowly now (every other second)
//		if ( client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH] && ((int)(level.time/1000))&0x01) {

		// NOW IT ONCE AGAIN counts down armor when over max, once per second
		if ( client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH]) {
			client->ps.stats[STAT_ARMOR]--;
		}

		// if we've got the seeker powerup, see if we can shoot it at someone
		//if ( client->ps.powerups[PW_FLASHLIGHT] )
		//{
			//vec3_t	seekerPos;

			//TiM - Because I commented out the scav code, I'm going to remove all other ref to it
			/*if (SeekerAcquiresTarget(ent, seekerPos)) // set the client's enemy to a valid target
			{
				FireSeeker( ent, ent->enemy, seekerPos );
				G_AddEvent( ent, EV_POWERUP_SEEKER_FIRE, 0 ); // draw the thingy
			}*/
		//}

		if ( !client->ps.stats[STAT_HOLDABLE_ITEM] )
		{//holding nothing...
			if ( client->ps.stats[STAT_USEABLE_PLACED] > 0 )
			{//we're in some kind of countdown
				//so count down
				client->ps.stats[STAT_USEABLE_PLACED]--;
			}
		}

	}
}

/*
====================
ClientIntermissionThink
====================
*/
void ClientIntermissionThink( gclient_t *client ) {
	client->ps.eFlags &= ~EF_TALK;
	client->ps.eFlags &= ~EF_FIRING;

	// the level will exit when everyone wants to or after timeouts

	// swap and latch button actions
	client->oldbuttons = client->buttons;
	client->buttons = client->pers.cmd.buttons;
	if (g_gametype.integer != GT_SINGLE_PLAYER)
	{
		if ( client->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) & ( client->oldbuttons ^ client->buttons ) ) {
			client->readyToExit ^= 1;
		}
	}
}

/*
====================
Cmd_Ready_f
====================
*/
/**
*	This function is called from the ui_sp_postgame.c as a result of clicking on the
*	"next" button in non GT_TOURNAMENT games.  This replaces the old system of waiting
*	for the user to click an ATTACK or USE button to signal ready
*	(see ClientIntermissionThink())
*
*	when all clients have signaled ready, the game continues to the next match.
*/
void Cmd_Ready_f (gentity_t *ent)
{
	gclient_t *client;
	client = ent->client;

	client->readyToExit ^= 1;
}



typedef struct detHit_s
{
	gentity_t	*detpack;
	gentity_t	*player;
	int			time;
} detHit_t;

#define MAX_DETHITS		32		// never define this to be 0

detHit_t	detHits[MAX_DETHITS];
qboolean	bDetInit = qfalse;

extern qboolean FinishSpawningDetpack( gentity_t *ent, int itemIndex );
//-----------------------------------------------------------------------------DECOY TEMP
extern qboolean FinishSpawningDecoy( gentity_t *ent, int itemIndex );
//-----------------------------------------------------------------------------DECOY TEMP
void DetonateDetpack(gentity_t *ent);

#define DETPACK_DAMAGE			750
#define DETPACK_RADIUS			500

/**
*	The detpack has been shot
*/
void detpack_shot( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
{
	int i = 0;
	gentity_t *ent = NULL;

	//so we can't be blown up by things we're blowing up
	self->takedamage = 0;

	G_TempEntity(self->s.origin, EV_GRENADE_EXPLODE);
	G_RadiusDamage( self->s.origin, self->parent?self->parent:self, DETPACK_DAMAGE*0.125, DETPACK_RADIUS*0.25,
		self, DAMAGE_ALL_TEAMS, MOD_DETPACK );
	// we're blowing up cuz we've been shot, so make sure we remove ourselves
	//from our parent's inventory (so to speak)
	for (i = 0; i < MAX_CLIENTS; i++)
	{
		if (((ent = &g_entities[i])!=NULL) && ent->inuse && (self->parent == ent))
		{
			ent->client->ps.stats[STAT_USEABLE_PLACED] = 0;
			ent->client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
			break;
		}
	}
	G_FreeEntity(self);
}

/**
*	Place the detpack
*/
qboolean PlaceDetpack(gentity_t *ent)
{
	gentity_t	*detpack = NULL;
	static gitem_t *detpackItem = NULL;
	float		detDistance = 80;
	trace_t		tr;
	vec3_t		fwd, right, up, end, mins = {-16,-16,-16}, maxs = {16,16,16};
	playerState_t *ps = &ent->client->ps;

	if (detpackItem == NULL)
	{
		detpackItem = BG_FindItemForHoldable(HI_DETPACK);
	}

	// make sure our detHit info is init'd
	if (!bDetInit)
	{
		memset(detHits, 0, MAX_DETHITS*sizeof(detHit_t));
		bDetInit = 1;
	}

	// can we place this in front of us?
	AngleVectors (ps->viewangles, fwd, right, up);
	fwd[2] = 0;
	VectorMA(ps->origin, detDistance, fwd, end);
	trap_Trace (&tr, ps->origin, mins, maxs, end, ent->s.number, MASK_SHOT );
	if (tr.fraction > 0.9)
	{
		// got enough room so place the detpack
		detpack = G_Spawn();
		G_SpawnItem(detpack, detpackItem);
		detpack->physicsBounce = 0.0f;//detpacks are *not* bouncy
		VectorMA(ps->origin, detDistance + mins[0], fwd, detpack->s.origin);
		if ( !FinishSpawningDetpack(detpack, detpackItem - bg_itemlist) )
		{
			return qfalse;
		}
		VectorNegate(fwd, fwd);
		vectoangles(fwd, detpack->s.angles);
		detpack->think = DetonateDetpack;
		detpack->nextthink = level.time + 120000;	// if not used after 2 minutes it blows up anyway
		detpack->parent = ent;
		return qtrue;
	}
	else
	{
		// no room
		return qfalse;
	}
}

/**
*	Was a player hit by a detpack.
*/
qboolean PlayerHitByDet(gentity_t *det, gentity_t *player)
{
	int i = 0;

	if (!bDetInit)
	{
		// detHit stuff not initialized. who knows what's going on?
		return qfalse;
	}
	for (i = 0; i < MAX_DETHITS; i++)
	{
		if ( (detHits[i].detpack == det) && (detHits[i].player == player) )
		{
			return qtrue;
		}
	}
	return qfalse;
}

/**
*	Addes a player to the detpack hits
*/
void AddPlayerToDetHits(gentity_t *det, gentity_t *player)
{
	int			i = 0;
	detHit_t	*lastHit = NULL, *curHit = NULL;

	for (i = 0; i < MAX_DETHITS; i++)
	{
		if (0 == detHits[i].time)
		{
			// empty slot. add our player here.
			detHits[i].detpack = det;
			detHits[i].player = player;
			detHits[i].time = level.time;
		}
		lastHit = &detHits[i];
	}
	// getting here means we've filled our list of detHits, so begin recycling them, starting with the oldest hit.
	curHit = &detHits[0];
	while (lastHit->time < curHit->time)
	{
		lastHit = curHit;
		curHit++;
		// just a safety check here
		if (curHit == &detHits[0])
		{
			break;
		}
	}
	curHit->detpack = det;
	curHit->player = player;
	curHit->time = level.time;
}

/**
*	Clear the hits for this detpack
*/
void ClearThisDetpacksHits(gentity_t *det)
{
	int			i = 0;

	for (i = 0; i < MAX_DETHITS; i++)
	{
		if (detHits[i].detpack == det)
		{
			detHits[i].player = NULL;
			detHits[i].detpack = NULL;
			detHits[i].time = 0;
		}
	}
}

void DetpackBlammoThink(gentity_t *ent)
{
	int i = 0, lifetime = 3000;	// how long (in msec) the shockwave lasts
	int			knockback = 400;
	float		curBlastRadius = 50.0*ent->count, radius = 0;
	vec3_t		vTemp;
	trace_t		tr;
	gentity_t	*pl = NULL;

	if (ent->count++ > (lifetime*0.01))
	{
		ClearThisDetpacksHits(ent);
		G_FreeEntity(ent);
		return;
	}

	// get a list of players within the blast radius at this time.
	// only hit the ones we can see from the center of the explosion.
	for (i=0; i<MAX_CLIENTS; i++)
	{
		if ( g_entities[i].client && g_entities[i].takedamage)
		{
			pl = &g_entities[i];
			VectorSubtract(pl->s.pos.trBase, ent->s.origin, vTemp);
			radius = VectorNormalize(vTemp);
			if ( (radius <= curBlastRadius) && !PlayerHitByDet(ent, pl) )
			{
				// within the proper radius. do we have LOS to the player?
				trap_Trace (&tr, ent->s.origin, NULL, NULL, pl->s.pos.trBase, ent->s.number, MASK_SHOT );
				if (tr.entityNum == i)
				{
					// oh yeah. you're gettin' hit.
					AddPlayerToDetHits(ent, pl);
					VectorMA(pl->client->ps.velocity, knockback, vTemp, pl->client->ps.velocity);
					// make sure the player goes up some
					if (pl->client->ps.velocity[2] < 100)
					{
						pl->client->ps.velocity[2] = 100;
					}
					if ( !pl->client->ps.pm_time )
					{
						int		t;

						t = knockback * 2;
						if ( t < 50 ) {
							t = 50;
						}
						if ( t > 200 ) {
							t = 200;
						}
						pl->client->ps.pm_time = t;
						pl->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
					}
				}
			}
			// this was just for testing. looks pretty neat, though.
/*
			else
			{
				VectorMA(ent->s.origin, curBlastRadius, vTemp, vTemp);
				G_TempEntity(vTemp, EV_FX_STEAM);
			}
*/
		}
	}

	ent->nextthink = level.time + FRAMETIME;
}

/**
*	Detonate a detpack
*/
void DetonateDetpack(gentity_t *ent)
{
	// find all detpacks. the one whose parent is ent...blow up
	gentity_t	*detpack = NULL;
	char		*classname = BG_FindClassnameForHoldable(HI_DETPACK);

	if (!classname)
	{
		return;
	}
	while ((detpack = G_Find (detpack, FOFS(classname), classname)) != NULL)
	{
		if (detpack->parent == ent)
		{
			// found it. BLAMMO!
			// play explosion sound to all clients
			gentity_t	*te = NULL;

			te = G_TempEntity( detpack->s.pos.trBase, EV_GLOBAL_SOUND );
			te->s.eventParm = G_SoundIndex( "sound/weapons/explosions/detpakexplode.wav" );//cgs.media.detpackExplodeSound
			te->r.svFlags |= SVF_BROADCAST;

			//so we can't be blown up by things we're blowing up
			detpack->takedamage = 0;

			G_AddEvent(detpack, EV_DETPACK, 0);
			G_RadiusDamage( detpack->s.origin, detpack->parent, DETPACK_DAMAGE, DETPACK_RADIUS,
				detpack, DAMAGE_HALF_NOTLOS|DAMAGE_ALL_TEAMS, MOD_DETPACK );
			// just turn the model invisible and let the entity think for a bit to deliver a shockwave
			//G_FreeEntity(detpack);
			detpack->classname = NULL;
			detpack->s.modelindex = 0;
			detpack->think = DetpackBlammoThink;
			detpack->count = 1;
			detpack->nextthink = level.time + FRAMETIME;
			return;
		}
		else if (detpack == ent)	// if detpack == ent, we're blowing up this detpack cuz it's been sitting too long
		{
			detpack_shot(detpack, NULL, NULL, 0, 0);
			return;
		}
	}
	// hmm. couldn't find it.
	detpack = NULL;
}





#define SHIELD_HEALTH				250
#define SHIELD_HEALTH_DEC			10		// 25 seconds
#define MAX_SHIELD_HEIGHT			1022 //254
#define MAX_SHIELD_HALFWIDTH		1023 //255
#define SHIELD_HALFTHICKNESS		4
#define SHIELD_PLACEDIST			64


static qhandle_t	shieldAttachSound=0;
static qhandle_t	shieldActivateSound=0;
static qhandle_t	shieldDamageSound=0;
//RPG-X: - RedTechie Added shild ZAPZPZAAAAAAppPPP sound!
static qhandle_t	shieldMurderSound=0;
static qhandle_t	shieldDeactivateSound=0;


/**
*	Remove a forcefield
*/
void ShieldRemove(gentity_t *self)
{
	self->think = G_FreeEntity;
	self->nextthink = level.time + 300;

	self->s.eFlags |= EF_ITEMPLACEHOLDER;

	// Play raising sound...
	G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);

	return;
}


/**
*	The think function of a forcefield
*	Does not do much anymore, once, counted down the health of a forcefield and removed
*	it when healt got equal or below zero.
*/
void ShieldThink(gentity_t *self)
{
	self->s.eFlags &= ~(EF_ITEMPLACEHOLDER | EF_NODRAW);
//	self->health -= SHIELD_HEALTH_DEC;
//	self->nextthink = level.time + 1000;
	self->nextthink = 0;
	//if (self->health <= 0)
	//{
	//	ShieldRemove(self);
	//}
	return;
}

/**
*	The shield was damaged to below zero health.
*/
void ShieldDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
{
	// Play damaging sound...
	G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

	ShieldRemove(self);
}


/**
*	The shield had damage done to it.  Make it flicker.
*/
void ShieldPain(gentity_t *self, gentity_t *attacker, int damage)
{
	// Set the itemplaceholder flag to indicate the the shield drawing that the shield pain should be drawn.
	self->s.eFlags |= EF_ITEMPLACEHOLDER;
	self->think = ShieldThink;
	self->nextthink = level.time + 400;

	// Play damaging sound...
	G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

	return;
}


/**
*	Try to turn the shield back on after a delay.
*/
void ShieldGoSolid(gentity_t *self)
{
	trace_t		tr;
	//gentity_t  *other;
	//other = G_Spawn();
	
	// see if we're valid
	//self->health--;
	if (self->health <= 0)
	{
		ShieldRemove(self);
		return;
	}

	trap_Trace (&tr, self->r.currentOrigin, self->r.mins, self->r.maxs, self->r.currentOrigin, self->s.number, CONTENTS_BODY );
	if(tr.startsolid)
	{	// gah, we can't activate yet
		self->nextthink = level.time + 200;
		self->think = ShieldGoSolid;
		trap_LinkEntity(self);
	}
	else
	{ // get hard... huh-huh...
		self->r.contents = CONTENTS_SOLID;
		self->s.eFlags &= ~(/*EF_NODRAW | */EF_ITEMPLACEHOLDER);
		self->nextthink = level.time + 1000;
		self->think = ShieldThink;
		self->takedamage = qtrue;//RPG-X: - RedTechie use to be qtrue //TiM - made true again. should be okay so long as the health isn't decremented
		
		trap_LinkEntity(self);


		// Play raising sound...
		//TiM No more
		//G_AddEvent(self, EV_GENERAL_SOUND, shieldActivateSound);
	}

	return;
}

/**
*	Turn the shield off to allow a friend to pass through.
*/
//RPG-X J2J EDIT here:
void ShieldGoNotSolid(gentity_t *self)
{
	// make the shield non-solid very briefly
	self->r.contents = CONTENTS_NONE;
//	self->s.eFlags |= EF_NODRAW;					//Commenting this should make it look like the player passes through..
	// nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
	self->nextthink = level.time + 200;
	self->think = ShieldGoSolid;

	//TiM - Make the field visible
	self->s.eFlags |= EF_ITEMPLACEHOLDER;

	self->takedamage = qfalse;
	trap_LinkEntity(self);

	// Play raising sound...
	G_AddEvent(self, EV_GENERAL_SOUND, shieldActivateSound);
}


/**
*	Somebody (a player) has touched the shield.  See if it is a "friend".
*/
void ShieldTouch(gentity_t *self, gentity_t *other, trace_t *trace)
{
	if ( !other || !other->client )
		return;

/*	if (g_gametype.integer >= GT_TEAM)
	{ // let teammates through
		// compare the parent's team to the "other's" team
		if (( self->parent->client) && (other->client))
		{
			if ( self->s.otherEntityNum2 == other->client->sess.sessionTeam || other->client->sess.sessionClass == PC_ALPHAOMEGA22 )
			{
				ShieldGoNotSolid(self);
			}
		}
	}
	else*/
	{//let the person who dropped the shield through
		if (IsAdmin(other) || (rpg_borgAdapt.integer && rpg_borgMoveThroughFields.integer && IsBorg(other))/*other->client->sess.sessionClass == PC_ADMIN*/ )
		{
			ShieldGoNotSolid(self);
		}
		//RPG-X:J2J Damage for shields 
		else
		{
			if ( (int)(self->s.angles[PITCH]) == 0 )
			{
				vec3_t	dir;

				//OPTIMIZE ME: If anyone can figure a quick, non hacky way to get the normal vector
				//of the side of the forcefield they touch, PLEASE put it here lol. THis way works, but feels very half-assed lol
				//Get the directional vector
				VectorSubtract( self->r.currentOrigin, other->r.currentOrigin, dir);
				VectorNormalize(dir);
				//depending on angle, negate the perpendicular direction (else they zap back sideways)
				//and set the other as absolute 
				if ( self->s.angles[YAW] == 0 ) {
					dir[1] = 0.0;
					if ( dir[0] < 0 )
						dir[0] = -1.0;
					else
						dir[0] = 1.0;
				}
				else {
					dir[0] = 0.0;
					if ( dir[1] < 0 )
						dir[1] = -1.0;
					else
						dir[1] = 1.0;
				}

				//Invert it otherwise we'd be like, sucked into the field lol
				VectorScale(dir, -1, dir);
				//Un-normalize it to represent a scalar quantity
				VectorScale( dir, 50, dir);
				//Copy it straight to our velocity (this will mean the player will literally be thrown back)
				VectorCopy( dir, other->client->ps.velocity );
				other->client->ps.pm_time = 160;		// hold time
				other->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;

				other->flags |= EF_MOVER_STOP;	//Attempt to not let non admins thru.
				//RPG-X: RedTechie - Added code for zap sound also a cvar to control damage a non admin walks into if cvar is set to 0 disables health from being drained (happens every 1 second)
				//if ( level.time >= level.message + 1000 ) {
				//	level.message = level.time;
				G_AddEvent(self, EV_GENERAL_SOUND, shieldMurderSound);//RPG-X: RedTechie - ZAPtacular! sound to my ears
				if(rpg_forcefielddamage.integer != 0){
					if(rpg_forcefielddamage.integer > 999){
						rpg_forcefielddamage.integer = 999;
					}
					other->health -= rpg_forcefielddamage.integer;
					
					//RPG-X: RedTechie - Fixed free ent if medic revive on
					if(rpg_medicsrevive.integer == 1){
						if(other->health <= 1){
							other->client->ps.stats[STAT_WEAPONS] = ( 1 << WP_0 );
							other->client->ps.stats[STAT_HOLDABLE_ITEM] = HI_NONE;
							other->client->ps.stats[STAT_HEALTH] = other->health = 1;
							player_die (other, other, other, 1, MOD_FORCEFIELD);
						}
					}else{
						if(other->health <= 1){
							other->client->ps.stats[STAT_HEALTH] = other->health = 0;
							player_die (other, other, other, 100000, MOD_FORCEFIELD);
						}
					}
				}
				//}
			}


			//TiM: make it flicker when touched, and then throw bak the person
			self->s.eFlags		|= EF_ITEMPLACEHOLDER;
			self->nextthink		= level.time + 150;
			self->think			= ShieldThink;
		}

	}
}

/**
*	After a short delay, create the shield by expanding in all directions.
*/
void CreateShield(gentity_t *ent)
{
	trace_t		tr;
	vec3_t		mins, maxs, end, posTraceEnd, negTraceEnd, start;
	int			height, posWidth, negWidth, halfWidth = 0;
	qboolean	xaxis;
	int			paramData = 0;
	//static int	shieldID;
	//gentity_t   *emitter;

	// trace upward to find height of shield
	VectorCopy(ent->r.currentOrigin, end);
	end[2] += MAX_SHIELD_HEIGHT;
	trap_Trace (&tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT );
	height = (int)(MAX_SHIELD_HEIGHT * tr.fraction);

	// use angles to find the proper axis along which to align the shield
	VectorSet(mins, -SHIELD_HALFTHICKNESS, -SHIELD_HALFTHICKNESS, 0);
	VectorSet(maxs, SHIELD_HALFTHICKNESS, SHIELD_HALFTHICKNESS, height);
	VectorCopy(ent->r.currentOrigin, posTraceEnd);
	VectorCopy(ent->r.currentOrigin, negTraceEnd);

	if ((int)(ent->s.angles[YAW]) == 0) // shield runs along y-axis
	{	
		ent->s.eFlags |= EF_SHIELD_BOX_Y;
		posTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;
		negTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
		xaxis = qfalse;
	}
	else  // shield runs along x-axis
	{
		ent->s.eFlags |= EF_SHIELD_BOX_X;
		posTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;
		negTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
		xaxis = qtrue;
	}

	// trace horizontally to find extend of shield
	// positive trace
	VectorCopy(ent->r.currentOrigin, start);
	start[2] += (height>>1);
	trap_Trace (&tr, start, 0, 0, posTraceEnd, ent->s.number, MASK_SHOT );
	posWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
	// negative trace
	trap_Trace (&tr, start, 0, 0, negTraceEnd, ent->s.number, MASK_SHOT );
	negWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;

	// kef -- monkey with dimensions and place origin in center
	halfWidth = (posWidth + negWidth)>>1;
	if (xaxis)
	{
		ent->r.currentOrigin[0] = ent->r.currentOrigin[0] - negWidth + halfWidth;
	}
	else
	{
		ent->r.currentOrigin[1] = ent->r.currentOrigin[1] - negWidth + halfWidth;
	}
	ent->r.currentOrigin[2] += (height>>1);

	// set entity's mins and maxs to new values, make it solid, and link it
	if (xaxis)
	{
		VectorSet(ent->r.mins, -halfWidth, -SHIELD_HALFTHICKNESS, -(height>>1));
		VectorSet(ent->r.maxs, halfWidth, SHIELD_HALFTHICKNESS, height);
	}
	else
	{
		VectorSet(ent->r.mins, -SHIELD_HALFTHICKNESS, -halfWidth, -(height>>1));
		VectorSet(ent->r.maxs, SHIELD_HALFTHICKNESS, halfWidth, height>>1);
	}
	ent->clipmask = MASK_SHOT;

	// scanable forcefield
	/*if(rpg_scannableForceField.integer) {
		VectorCopy(maxs, ent->s.origin2);
		VectorCopy(mins, ent->s.angles2);
		trap_LinkEntity(ent);
	}*/

	// Information for shield rendering.

//	xaxis - 1 bit
//	height - 0-254 8 bits //10
//	posWidth - 0-255 8 bits //10
//  negWidth - 0 - 255 8 bits

	paramData = (xaxis << 30) | ((height&1023) << 20) | ((posWidth&1023) << 10) | (negWidth&1023); //24 16 8
	ent->s.time2 = paramData;

	if ( ent->s.otherEntityNum2 == TEAM_RED )
	{
		ent->team = "1";
	}
	else if ( ent->s.otherEntityNum2 == TEAM_BLUE )
	{
		ent->team = "2";
	}
	
	//RPG-X: - RedTechie no shield count down
	if ( g_pModSpecialties.integer != 0 )
	{
		//ent->health = ceil(SHIELD_HEALTH*4*g_dmgmult.value);
	}
	else
	{
		ent->health = ceil(SHIELD_HEALTH*g_dmgmult.value);
	}
	
	
	ent->s.time = ent->health;//???
	ent->pain = ShieldPain;
	ent->die = ShieldDie;
	ent->touch = ShieldTouch;
	
	ent->r.svFlags |= SVF_SHIELD_BBOX;

	// see if we're valid
	trap_Trace (&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, CONTENTS_BODY );

	if (tr.startsolid)
	{	// Something in the way!
		// make the shield non-solid very briefly
		ent->r.contents = CONTENTS_NONE;
		ent->s.eFlags |= EF_NODRAW;
		// nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
		ent->nextthink = level.time + 200;
		ent->think = ShieldGoSolid;
		ent->takedamage = qfalse;
		trap_LinkEntity(ent);
	}
	else
	{	// Get solid.
		ent->r.contents = CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP;//CONTENTS_SOLID;

		ent->nextthink = level.time + 400; //1000
		ent->think = ShieldThink;

		ent->takedamage = qtrue;//RPG-X: - RedTechie Use to be qtrue //TiM - made true again. should be okay so long as the health isn't decremented
		trap_LinkEntity(ent);

		ent->s.eFlags |= EF_ITEMPLACEHOLDER;

		// Play raising sound...
		G_AddEvent(ent, EV_GENERAL_SOUND, shieldActivateSound);
	}

	return;
}

// After a short delay, create the shield by expanding in all directions.
//void CreateFlatShield(gentity_t *ent)
//{
//	trace_t		tr;
//	vec3_t		mins, maxs, end, posTraceEnd, negTraceEnd, start;
//	int			height, posWidth, negWidth, halfWidth = 0;
//	qboolean	xaxis;
//	int			paramData = 0;
//	static int	shieldID;
//
//	// trace upward to find height of shield
//	VectorCopy(ent->r.currentOrigin, end);
//	if ( (int)(ent->s.angles[YAW]) == 0 )
//	{
//		if ( ent->timestamp )
//			end[1] += MAX_SHIELD_HEIGHT;
//		else
//			end[1] -= MAX_SHIELD_HEIGHT;
//	}
//	else
//	{
//		if ( ent->timestamp )
//			end[0] += MAX_SHIELD_HEIGHT;
//		else
//			end[0] -= MAX_SHIELD_HEIGHT;
//	}
//	
//	trap_Trace (&tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT );
//	height = (int)(MAX_SHIELD_HEIGHT * tr.fraction);
//
//	// use angles to find the proper axis along which to align the shield
//	if ( (int)(ent->s.angles[YAW]) == 0 ) {
//		VectorSet(mins, -SHIELD_HALFTHICKNESS, 0, -SHIELD_HALFTHICKNESS);
//		VectorSet(maxs, SHIELD_HALFTHICKNESS, height, SHIELD_HALFTHICKNESS);
//	}
//	else
//	{
//		VectorSet(mins, 0, -SHIELD_HALFTHICKNESS, -SHIELD_HALFTHICKNESS);
//		VectorSet(maxs, height, SHIELD_HALFTHICKNESS, SHIELD_HALFTHICKNESS);
//	}
//	VectorCopy(ent->r.currentOrigin, posTraceEnd);
//	VectorCopy(ent->r.currentOrigin, negTraceEnd);
//
//	if ((int)(ent->s.angles[YAW]) == 0) // shield runs along y-axis
//	{
//		//posTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;
//		//negTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
//		if ( ent->timestamp )
//		{
//			posTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;
//			negTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
//		}
//		else
//		{
//			posTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
//			negTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;			
//		}
//		xaxis = qfalse;
//	}
//	else  // shield runs along x-axis
//	{
//		//posTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;
//		//negTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
//		if ( ent->timestamp )
//		{
//			posTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;
//			negTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
//		}
//		else
//		{
//			posTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
//			negTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;			
//		}
//
//		xaxis = qtrue;
//	}
//
//	// trace horizontally to find extend of shield
//	// positive trace
//	VectorCopy(ent->r.currentOrigin, start);
//	if ( (int)(ent->s.angles[YAW]) == 0 )
//	{
//		if ( ent->timestamp )
//			start[1] += (height>>1);
//		else
//			start[1] -= (height>>1);
//	}
//	else
//	{	
//		if ( ent->timestamp )
//			start[0] += (height>>1);
//		else
//			start[0] -= (height>>1);
//	}
//	trap_Trace (&tr, start, 0, 0, posTraceEnd, ent->s.number, MASK_SHOT );
//	posWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
//	// negative trace
//	trap_Trace (&tr, start, 0, 0, negTraceEnd, ent->s.number, MASK_SHOT );
//	negWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
//
//	// kef -- monkey with dimensions and place origin in center
//	halfWidth = (posWidth + negWidth)>>1;
//	if (xaxis)
//	{
//		ent->r.currentOrigin[0] = ent->r.currentOrigin[0] - negWidth + halfWidth;
//	}
//	else
//	{
//		ent->r.currentOrigin[1] = ent->r.currentOrigin[1] - negWidth + halfWidth;
//	}
//	if ( (int)(ent->s.angles[YAW]) == 0 )
//	{
//		if ( ent->timestamp )
//			ent->r.currentOrigin[1] += (height>>1);
//		else
//			ent->r.currentOrigin[1] -= (height>>1);
//	}
//	else
//	{
//		if ( ent->timestamp )
//			ent->r.currentOrigin[0] += (height>>1);
//		else
//			ent->r.currentOrigin[0] -= (height>>1);
//	}
//
//	// set entity's mins and maxs to new values, make it solid, and link it
//	if (xaxis)
//	{
//		VectorSet(ent->r.mins, -halfWidth, -(height>>1), -SHIELD_HALFTHICKNESS);
//		VectorSet(ent->r.maxs, halfWidth, height, SHIELD_HALFTHICKNESS);
//	}
//	else
//	{
//		VectorSet(ent->r.mins, -(height>>1), -halfWidth, -SHIELD_HALFTHICKNESS );
//		VectorSet(ent->r.maxs, height>>1, halfWidth, SHIELD_HALFTHICKNESS );
//	}
//	ent->clipmask = MASK_SHOT;
//
//	// Information for shield rendering.
//
////	vertical - 1 bit
////	xaxis - 1 bit
////	height - 0-254 8 bits //10
////	posWidth - 0-255 8 bits //10
////  negWidth - 0 - 255 8 bits
//
//	paramData = (ent->timestamp << 32 ) | (1 << 31) |(xaxis << 30) | (height << 20) | (posWidth << 10) | (negWidth); //24 16 8
//	ent->s.time2 = paramData;
//
//	if ( ent->s.otherEntityNum2 == TEAM_RED )
//	{
//		ent->team = "1";
//	}
//	else if ( ent->s.otherEntityNum2 == TEAM_BLUE )
//	{
//		ent->team = "2";
//	}
//	
//	//RPG-X: - RedTechie no shield count down
//	if ( g_pModSpecialties.integer != 0 )
//	{
//		//ent->health = ceil(SHIELD_HEALTH*4*g_dmgmult.value);
//	}
//	else
//	{
//		ent->health = ceil(SHIELD_HEALTH*g_dmgmult.value);
//	}
//	
//	
//	ent->s.time = ent->health;//???
//	ent->pain = ShieldPain;
//	ent->die = ShieldDie;
//	ent->touch = ShieldTouch;
//	
//	ent->r.svFlags |= SVF_SHIELD_BBOX;
//
//	// see if we're valid
//	trap_Trace (&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, CONTENTS_BODY );
//
//	if (tr.startsolid)
//	{	// Something in the way!
//		// make the shield non-solid very briefly
//		ent->r.contents = CONTENTS_NONE;
//		ent->s.eFlags |= EF_NODRAW;
//		// nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
//		ent->nextthink = level.time + 200;
//		ent->think = ShieldGoSolid;
//		ent->takedamage = qfalse;
//		trap_LinkEntity(ent);
//	}
//	else
//	{	// Get solid.
//		ent->r.contents = CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP;//CONTENTS_SOLID;
//
//		ent->nextthink = level.time + 400; //1000
//		ent->think = ShieldThink;
//
//		ent->takedamage = qtrue;//RPG-X: - RedTechie Use to be qtrue //TiM - made true again. should be okay so long as the health isn't decremented
//		trap_LinkEntity(ent);
//
//		ent->s.eFlags |= EF_ITEMPLACEHOLDER;
//
//		// Play raising sound...
//		G_AddEvent(ent, EV_GENERAL_SOUND, shieldActivateSound);
//	}
//
//	return;
//}

/**
*	Place a forcefield
*/
qboolean PlaceShield(gentity_t *playerent)
{
	static const gitem_t *shieldItem = NULL;
	gentity_t	*shield = NULL;
	trace_t		tr;
	vec3_t		fwd, pos, dest, mins = {-16,-16, 0}, maxs = {16,16,16};
	playerState_t *ps = &playerent->client->ps;

	if (shieldAttachSound==0)
	{
		shieldAttachSound		= G_SoundIndex("sound/weapons/detpacklatch.wav");
		shieldActivateSound		= G_SoundIndex("sound/movers/forcefield/forcefieldon.wav"); //"sound/movers/forceup.wav"
		shieldDamageSound		= G_SoundIndex("sound/ambience/spark5.wav");
		shieldMurderSound		= G_SoundIndex("sound/movers/forcefield/forcefieldtouch.wav"); //RPG-X: - RedTechie Added shild ZAP! sound //sound/world/electro.wav
		shieldDeactivateSound	= G_SoundIndex("sound/movers/forcefield/forcefieldoff.wav");
		shieldItem = BG_FindItemForHoldable(HI_SHIELD);
	}

	// can we place this in front of us?
	AngleVectors (ps->viewangles, fwd, NULL, NULL);
	fwd[2] = 0;
	VectorMA(ps->origin, SHIELD_PLACEDIST, fwd, dest);
	trap_Trace (&tr, ps->origin, mins, maxs, dest, playerent->s.number, MASK_SHOT );
	if (tr.fraction > 0.9)
	{//room in front
		VectorCopy(tr.endpos, pos);
		// drop to floor
		VectorSet( dest, pos[0], pos[1], pos[2] - 4096 );
		trap_Trace( &tr, pos, mins, maxs, dest, playerent->s.number, MASK_SOLID );
		if ( !tr.startsolid && !tr.allsolid )
		{
			// got enough room so place the portable shield
			shield = G_Spawn();

			if(!shield || !shieldItem) return qfalse;

			// Figure out what direction the shield is facing.
			if (fabs(fwd[0]) > fabs(fwd[1]))
			{	// shield is north/south, facing east.
				shield->s.angles[YAW] = 0;
			}
			else
			{	// shield is along the east/west axis, facing north
				shield->s.angles[YAW] = 90;
			}
			shield->think = CreateShield;
			shield->nextthink = level.time + 500;	// power up after .5 seconds
			shield->parent = playerent;

			// Set team number.
			shield->s.otherEntityNum2 = playerent->client->sess.sessionTeam;

			shield->s.eType = ET_USEABLE;
			shield->s.modelindex =  HI_SHIELD;	// this'll be used in CG_Useable() for rendering.
			shield->classname = shieldItem->classname;

			shield->r.contents = CONTENTS_TRIGGER;

			shield->touch = 0;
			// using an item causes it to respawn
			shield->use = 0; //Use_Item;

			// allow to ride movers
			shield->s.groundEntityNum = tr.entityNum;

			G_SetOrigin( shield, tr.endpos );

			shield->s.origin2[0] = rpg_forceFieldColor.integer;

			shield->s.eFlags &= ~EF_NODRAW;
			shield->r.svFlags &= ~SVF_NOCLIENT;

			// add frequency
			/*if(rpg_scannableForceField.integer) {
				if(rpg_forceFieldFreq.integer == -1) {
					shield->s.apos.trBase[0] = -1;
				} else {
					shield->s.apos.trBase[0] = rpg_forceFieldFreq.value;
				}
			}*/

			trap_LinkEntity (shield);

			// Play placing sound...
			G_AddEvent(shield, EV_GENERAL_SOUND, shieldAttachSound);

			return qtrue;
		}
	}

	//GARRRGH Screw this! It'll take too long!
	//TiM - For a horizontal field, aim it at a vertical plane
	//if ( tr.fraction != 1.0 && tr.plane.normal[2] == 0.0f )
	//{
	//	qboolean	positive;

	//	//VectorCopy(tr.endpos, pos);
	//	// drop to floor
	//	if ( Q_fabs(tr.plane.normal[0] ) > Q_fabs(tr.plane.normal[1]) )
	//	{
	//		//VectorSet( dest, (tr.plane.normal[0]>0 ? pos[0] + 4096 : pos[0] - 4096), pos[1], pos[2] );
	//		positive = (tr.plane.normal[0]>0);
	//	}
	//	else
	//	{
	//		//VectorSet( dest, pos[0], (tr.plane.normal[1]>0 ? pos[1] + 4096 : pos[1] - 4096), pos[2] );
	//		positive = (tr.plane.normal[1]>0);
	//	}

	//	//trap_Trace( &tr, pos, mins, maxs, dest, playerent->s.number, MASK_SOLID );

	//	if ( !tr.startsolid && !tr.allsolid )
	//	{
	//		// got enough room so place the portable shield
	//		shield = G_Spawn();

	//		// Figure out what direction the shield is facing.
	//		if (fabs(fwd[0]) > fabs(fwd[1]))
	//		{	// shield is north/south, facing east.
	//			shield->s.angles[YAW] = 0;
	//		}
	//		else
	//		{	// shield is along the east/west axis, facing north
	//			shield->s.angles[YAW] = 90;
	//		}
	//		shield->s.angles[PITCH] = 90;
	//		shield->timestamp = positive;

	//		shield->think = CreateFlatShield;
	//		shield->nextthink = level.time + 500;	// power up after .5 seconds
	//		shield->parent = playerent;

	//		// Set team number.
	//		shield->s.otherEntityNum2 = playerent->client->sess.sessionTeam;

	//		shield->s.eType = ET_USEABLE;
	//		shield->s.modelindex =  HI_SHIELD;	// this'll be used in CG_Useable() for rendering.
	//		shield->classname = shieldItem->classname;

	//		shield->r.contents = CONTENTS_TRIGGER;

	//		shield->touch = 0;
	//		// using an item causes it to respawn
	//		shield->use = 0; //Use_Item;

	//		// allow to ride movers
	//		shield->s.groundEntityNum = tr.entityNum;

	//		G_SetOrigin( shield, tr.endpos );

	//		shield->s.eFlags &= ~EF_NODRAW;
	//		shield->r.svFlags &= ~SVF_NOCLIENT;

	//		trap_LinkEntity (shield);

	//		// Play placing sound...
	//		G_AddEvent(shield, EV_GENERAL_SOUND, shieldAttachSound);

	//		return qtrue;
	//	}
	//}
	// no room
	return qfalse;
}



//-------------------------------------------------------------- DECOY ACTIVITIES
/**
*	Think function for decoys, decoys are spawnchars in RPG-X
*/
void DecoyThink(gentity_t *ent)
{
	ent->s.apos =(ent->parent)->s.apos;					// Update Current Rotation
	ent->nextthink = level.time + irandom(2000, 6000);	// Next think between 2 & 8 seconds

	(ent->count) --;									// Count Down
	if (ent->count<0)			G_FreeEntity(ent);		// Time To Erase The Ent
}

//TiM : I was just able to spawn 600 copies of me...
//my fps died and my PC started making weird noises
//We'd better instigate a limit to our spawning here...
//Borrowed from the tripMines
/**
*	Safety function to limit ammount of decoys spawned at one time and overall.
*	Stops spawning if to many are spawned a a time, stop spawning is a limit was hit.
*	\author Ubergames - TiM
*/
void flushDecoys( gentity_t	*ent ) {
	gentity_t	*decoy = NULL;
	int			foundDecoys[MAX_GENTITIES] = {ENTITYNUM_NONE};
	int			lowestTimeStamp;
	int			orgCount;
	int			decoyCount=0;
	int			removeMe;
	int			i;

	//limit to 10 placed at any one time
	//see how many there are now
	while ( (decoy = G_Find( decoy, FOFS(classname), "decoy" )) != NULL )
	{
		if ( decoy->parent != ent )
		//if ( decoy->s.clientNum != ent->client->ps.clientNum )
		{
			continue;
		}
		foundDecoys[decoyCount++] = decoy->s.clientNum;
	}
	
	//G_Printf("Found %i decoys\n", decoyCount++ ) ;

	//now remove first ones we find until there are only 9 left
	decoy = NULL;
	orgCount = decoyCount;
	lowestTimeStamp = level.time;
	
	//RPG-X: TiM - Let's limit it to say... 64 decoys per player
	while ( decoyCount > 64 ) //9
	{
		removeMe = -1;
		for ( i = 0; i < orgCount; i++ )
		{
			if ( foundDecoys[i] == ENTITYNUM_NONE )
			{
				continue;
			}
			decoy = &g_entities[foundDecoys[i]];
		
			if ( decoy && decoy->timestamp < lowestTimeStamp )
			{
				removeMe = i;
				lowestTimeStamp = decoy->timestamp;
			}
		}

		if ( removeMe != -1 )
		{
			//remove it... or blow it?
			if ( &g_entities[foundDecoys[removeMe]] == NULL )
			{
				break;
			}
			else
			{
				G_FreeEntity( &g_entities[foundDecoys[removeMe]] );
			}
			foundDecoys[removeMe] = ENTITYNUM_NONE;
			decoyCount--;
		}
		else
		{
			break;
		}	
	}
}
 
/**
*	entities spawn non solid and through this function,
*	they'll become solid once nothing's detected in their boundaries. :)
*	\author TiM
*/
void Decoy_CheckForSolidity( gentity_t	*ent ) {
	int			i, num;
	int			touch[MAX_GENTITIES];
	qboolean	canGoSolid=qtrue;
	gentity_t	*hit;
	vec3_t		mins, maxs;

	VectorAdd( ent->s.origin, ent->r.mins, mins );
	VectorAdd( ent->s.origin, ent->r.maxs, maxs );

	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

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

		if ( hit  && hit->client ) {
			canGoSolid = qfalse;
			break;
		}	
	}

	if ( canGoSolid ) {
		ent->r.contents = MASK_PLAYERSOLID;
		ent->nextthink = 0;
		ent->think = 0;
	}
	else {
		ent->nextthink = level.time + 1000;
		ent->r.contents = CONTENTS_NONE;
	}
}

/**
*	Use function for decoy, removes it if activator is an player and admin
*/
void DecoyUse ( gentity_t *self, gentity_t *other, gentity_t *activator ) {
	if ( !activator || !IsAdmin( activator ) || !activator->client )
		return;

	G_FreeEntity( self );

}

/**
*	Spawn a char
*/	
qboolean PlaceDecoy(gentity_t *ent)
{
	gentity_t	*decoy = NULL;
	static gitem_t *decoyItem = NULL;
	//float		detDistance = 80;	// Distance the object will be placed from player
	//trace_t		tr;
	vec3_t		/*fwd, right, up, end,*/ mins = {-16,-16,-24}; //, maxs = {16,16,16};
	char		userinfo[MAX_INFO_STRING];
	int			i;

	if (decoyItem == NULL)
	{
		decoyItem = BG_FindItemForHoldable(HI_DECOY);
	}

	// can we place this in front of us?
	//AngleVectors (ent->client->ps.viewangles, fwd, right, up);
	//fwd[2] = 0;
	//VectorMA(ent->client->ps.origin, detDistance, fwd, end);
	//trap_Trace (&tr, ent->client->ps.origin, mins, maxs, end, ent->s.number, MASK_SHOT );
	//if ( /*!tr.allsolid && !tr.startsolid && tr.fraction > 0.9*/ qtrue )
	{
		//If we just hit our 129th decoy (...holy crap), reset the counter
		if ( level.decoyIndex >= MAX_CLIENTS ) {
			level.decoyIndex = 0;
		}
		//Now check if there is already a decoy with the same eventParm index.  If there is, terminate it
		{	
			gentity_t	*oldDecoy;

			for ( i = 0; i<level.num_entities; i++ ) {
			oldDecoy = &g_entities[i];

				if ( !Q_stricmp( oldDecoy->classname, "decoy" ) && oldDecoy->s.eventParm == level.decoyIndex ) {
					G_FreeEntity( oldDecoy );
					break;
				}
			}
		}

		//--------------------------- SPAWN AND PLACE DECOY ON GROUND
		decoy = G_Spawn();

		G_SpawnItem(decoy, decoyItem);				// Generate it as an item, temporarly
		decoy->physicsBounce = 0.0f;//decoys are *not* bouncy
		//VectorMA(ent->client->ps.origin, detDistance + mins[0], fwd, decoy->s.origin);
		VectorCopy( ent->client->ps.origin, decoy->s.origin );
		decoy->r.mins[2] = mins[2];//keep it off the floor
		//VectorNegate(fwd, fwd);					// ???  What does this do??
		//vectoangles(fwd, decoy->s.angles);
		VectorCopy( ent->client->ps.viewangles, decoy->s.angles );
		if ( !FinishSpawningDecoy(decoy, decoyItem - bg_itemlist) )
		{
			return qfalse;		// Drop to ground and trap to clients
		}
		decoy->s.clientNum = ent->client->ps.clientNum;
		decoy->s.number = decoy-g_entities;

		//--------------------------- SPECIALIZED DECOY SETUP
		//decoy->think = DecoyThink;
		//decoy->count = 12;						// about 1 minute before dissapear
		//decoy->nextthink = level.time + 4000;	// think after 4 seconds
		decoy->parent = ent;

		(decoy->s).eType = (ent->s).eType;		// set to type PLAYER
		(decoy->s).eFlags= (ent->s).eFlags;
		(decoy->s).eFlags |= EF_ITEMPLACEHOLDER;// set the HOLOGRAM FLAG to ON
		(decoy->s).powerups = (ent->s).powerups;

		//TiM - attach the rotate flag if we need to
		if ( (ent->s).powerups & ( 1<<PW_FLIGHT ) || ent->client->ps.gravity == 0 )
			(decoy->s).eFlags |= EF_FULL_ROTATE;

		decoy->s.eFlags &= ~(EF_FIRING | EF_ALT_FIRING);

		decoy->s.weapon = ent->s.weapon;		// get Player's Wepon Type
//		decoy->s.constantLight = 10 + (10 << 8) + (10 << 16) + (9 << 24);

		//decoy->s.pos.trBase[2] += 24;			// shift up to adjust origin of body
		decoy->s.apos = ent->s.apos;			// copy angle of player to decoy
		decoy->s.pos  = ent->s.pos;

		//decoy->s.legsAnim = BOTH_STAND1;			// Just standing TORSO_STAND
		//decoy->s.torsoAnim = BOTH_STAND1;
		//TiM: Set it's anim to whatever anims we're playing right now
		decoy->s.legsAnim = ent->client->ps.stats[LEGSANIM];
		decoy->s.torsoAnim= ent->client->ps.stats[TORSOANIM];

		decoy->timestamp = level.time;

		//--------------------------- WEAPON ADJUST
		//if (decoy->s.weapon==WP_5 /*|| decoy->s.weapon==WP_13*/)
		//	decoy->s.weapon = WP_1;

		//   The Phaser and Dreadnought (Arc Welder) weapons are rendered on the
		//   client side differently, and cannot be used by the decoy
		decoy->classname = "decoy";
		//flushDecoys( ent );

		//TiM-Set up data for transmission to client
		decoy->s.eventParm = level.decoyIndex;
		decoy->r.contents = CONTENTS_SOLID;	//has to start off solid, or CGame won't realise this

		VectorSet( decoy->r.mins, DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2 );
		VectorSet( decoy->r.maxs, DEFAULT_MAXS_0, DEFAULT_MAXS_1, DEFAULT_MAXS_2 );

		decoy->nextthink = level.time + FRAMETIME;
		decoy->think = Decoy_CheckForSolidity;
		decoy->use = DecoyUse;

		trap_GetUserinfo( ent->client->ps.clientNum, userinfo, sizeof(userinfo) );
		{
			char buffer[MAX_TOKEN_CHARS];
			char model[64];
			char height[9];
			char weight[9];
			char offset[6];
			
			//TiM - ensure that we encapsulate this data better or else it sometimes
			//becomes null
			Q_strncpyz( model, Info_ValueForKey( userinfo, "model" ), sizeof( model ) );
			Q_strncpyz( height, Info_ValueForKey( userinfo, "height" ), sizeof( height ) );
			Q_strncpyz( weight, Info_ValueForKey( userinfo, "weight" ), sizeof( weight ) );
			Q_strncpyz( offset, Info_ValueForKey( userinfo, "modelOffset" ), sizeof( offset ) );

			Com_sprintf( buffer, sizeof( buffer ), "model\\%s\\height\\%s\\weight\\%s\\moOf\\%s\\c\\%i", 
													model,
													height,
													weight,
													offset,
													ent->client->sess.sessionClass );

			trap_SetConfigstring( CS_DECOYS + level.decoyIndex, buffer );

			//G_Printf( S_COLOR_BLUE "level.decoyIndex: %i\n", level.decoyIndex );
			//G_Printf( S_COLOR_BLUE "%s\n", buffer );
		}
		level.decoyIndex++;

		return qtrue;						// SUCCESS
	}
	/*else
	{
		return qfalse;						// FAILURE: no room
	}*/
}
//-------------------------------------------------------------- DECOY ACTIVITIES

void G_Rematerialize( gentity_t *ent )
{
	playerState_t *ps = &ent->client->ps;

	if ( ent->s.number == borgQueenClientNum )
	{
		ent->client->teleportTime = level.time + ( 60 * 1000 );
		ps->stats[STAT_USEABLE_PLACED] = 60;
	}
	else
	{
		ent->client->teleportTime = level.time + ( 15 * 1000 );
		ps->stats[STAT_USEABLE_PLACED] = 15;
	}
	ent->flags &= ~FL_NOTARGET;
	ent->takedamage = qtrue;
	ent->r.contents = MASK_PLAYERSOLID;
	ent->s.eFlags &= ~EF_NODRAW;
	ps->eFlags &= ~EF_NODRAW;
	TeleportPlayer( ent, ps->origin, ps->viewangles, TP_BORG );
	//ps->stats[STAT_USEABLE_PLACED] = 0;
	//take it away
	ps->stats[STAT_HOLDABLE_ITEM] = 0;
}

void G_GiveHoldable( gclient_t *client, holdable_t item )
{
	gitem_t	*holdable = BG_FindItemForHoldable( item );

	client->ps.stats[STAT_HOLDABLE_ITEM] = holdable - bg_itemlist;//teleport spots should be on other side of map
	RegisterItem( holdable );
}

/*
================
ClientEvents
================
*/
/**
*	Events will be passed on to the clients for presentation,
*	but any server game effects are handled here
*/
void ClientEvents( gentity_t *ent, int oldEventSequence ) {
	int		i;
	int		event;
	gclient_t *client;
	int		damage;
	playerState_t *ps;

	client = ent->client;
	ps = &client->ps;

	if ( oldEventSequence < ps->eventSequence - MAX_PS_EVENTS ) {
		oldEventSequence = ps->eventSequence - MAX_PS_EVENTS;
	}
	for ( i = oldEventSequence ; i < ps->eventSequence ; i++ ) {
		event = ps->events[ i & (MAX_PS_EVENTS-1) ];

		switch ( event ) {
		case EV_FALL_MEDIUM:
		case EV_FALL_FAR:
			if ( ent->s.eType != ET_PLAYER ) {
				break;		// not in the player model
			}
			if ( g_dmflags.integer & DF_NO_FALLING ) {
				break;
			}
			if ( rpg_selfdamage.integer != 0 )
			{
				if ( event == EV_FALL_FAR )
				{
					damage = 110; //10 -TiM : Make the falling more realistc!
				}
				else
				{
					damage = 90; //5
				}
			}
			else
			{
				damage = 0;
			}
			ent->pain_debounce_time = level.time + 200;	// no normal pain sound
			G_Damage (ent, NULL, NULL, NULL, NULL, damage, DAMAGE_ARMOR_PIERCING, MOD_FALLING);

			break;

		case EV_FIRE_WEAPON:
			FireWeapon( ent, qfalse );
			break;

		case EV_ALT_FIRE:
			FireWeapon( ent, qtrue );
			break;

		case EV_FIRE_EMPTY_PHASER:
			FireWeapon( ent, qfalse );
			break;

		case EV_USE_ITEM1:		// transporter

			//------------------------------------------------------- DROP FLAGS
			/*if      ( ps->powerups[PW_REDFLAG] ) {
				Team_ReturnFlag(TEAM_RED);
			}*/
			/*else if ( ps->powerups[PW_BORG_ADAPT] ) {
				Team_ReturnFlag(TEAM_BLUE);
			}*/
			//ps->powerups[PW_BORG_ADAPT] = 0;
			//ps->powerups[PW_REDFLAG]  = 0;
			//------------------------------------------------------- DROP FLAGS
			if ( qfalse/*client->sess.sessionClass == PC_BORG*/ )
			{
				if ( !ps->stats[STAT_USEABLE_PLACED] )
				{//go into free-roaming mode
					gentity_t	*tent;
					//FIXME: limit this to 10 seconds
					ent->flags |= FL_NOTARGET;
					ent->takedamage = qfalse;
					ent->r.contents = CONTENTS_PLAYERCLIP;
					ent->s.eFlags |= EF_NODRAW;
					ps->eFlags |= EF_NODRAW;
					ps->stats[STAT_USEABLE_PLACED] = 2;
					client->teleportTime = level.time + 10000;
					tent = G_TempEntity( ps->origin, EV_BORG_TELEPORT );
					tent->s.clientNum = ent->s.clientNum;
				}
				else
				{//come out of free-roaming mode, teleport to current position
					G_Rematerialize( ent );
				}
			}
			else// get rid of transporter and go to random spawnpoint
			{
				//vec3_t	origin, angles;
				//gentity_t	*tent;

				//SelectSpawnPoint( ps->origin, origin, angles );

				//if(TransDat[ps->clientNum].pUsed == qfalse)
				//TiM: Since we purge the vectors each cycle.  I'll save us some memory by using the vectors themselves as a check.
				if ( TransDat[ps->clientNum].beamTime == 0 && 
					VectorCompare( vec3_origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin ) &&
					 VectorCompare( vec3_origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles ) )
				{
					VectorCopy( ps->origin, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin );
					VectorCopy( ps->viewangles, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles );
					//VectorCopy(ps->origin, TransDat[ps->clientNum].pTransCoord);
					//VectorCopy(ps->viewangles, TransDat[ps->clientNum].pTransCoordRot);
					//TransDat[ps->clientNum].pUsed = qtrue;
					trap_SendServerCommand( ent-g_entities, va("chat \"Site to Site Transporter Location Confirmed.\nPress again to Energize.\"", Q_COLOR_ESCAPE));
					//trap_SendConsoleCommand( EXEC_APPEND, va("echo Site to Site Transporter Location Confirmed.\necho Press again to Energize.") );
					ps->stats[STAT_HOLDABLE_ITEM] = BG_FindItemForHoldable( HI_TRANSPORTER ) - bg_itemlist;
					ps->stats[STAT_USEABLE_PLACED] = 2; // = 1
					break;
				}

				//TeleportPlayer( ent, TransDat[ps->clientNum].pTransCoord, TransDat[ps->clientNum].pTransCoordRot, TP_NORMAL );
				if ( TransDat[ps->clientNum].beamTime == 0 && level.time > ps->powerups[PW_QUAD] ) {
					G_InitTransport( ps->clientNum, TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].origin,
									TransDat[ps->clientNum].storedCoord[TPT_PORTABLE].angles );

					memset( &TransDat[ps->clientNum].storedCoord[TPT_PORTABLE], 0, sizeof( TransDat[ps->clientNum].storedCoord[TPT_PORTABLE]) );
				}
				else {
					trap_SendServerCommand( ent-g_entities, va("chat \"Unable to comply. Already within transport cycle.\"", Q_COLOR_ESCAPE));
				}

				ps->stats[STAT_USEABLE_PLACED] = 0;
				
				if (g_classData[client->sess.sessionClass].isMarine/* client->sess.sessionClass == PC_ALPHAOMEGA22*/ )
				{
					client->teleportTime = level.time + ( 3 * 1000 ); // 15 * 1000
					ps->stats[STAT_USEABLE_PLACED] = 1; // = 1
				}
					
			}
			break;

		case EV_USE_ITEM2:		// medkit
			// New set of rules.  You get either 100 health, or an extra 25, whichever is higher.
			// Give 1/4 health.
			ent->health += ps->stats[STAT_MAX_HEALTH]*0.25;

			if (ent->health < ps->stats[STAT_MAX_HEALTH])
			{	// If that doesn't bring us up to 100, make it go up to 100.
				ent->health = ps->stats[STAT_MAX_HEALTH];
			}
			else if (ent->health > ps->stats[STAT_MAX_HEALTH]*2)
			{	// Otherwise, 25 is all you get.  Just make sure we don't go above 200.
				ent->health = ps->stats[STAT_MAX_HEALTH]*2;
			}
			break;

		case EV_USE_ITEM3:		// detpack
			// if we haven't placed it yet, place it
			if (0 == ps->stats[STAT_USEABLE_PLACED])
			{
				if ( PlaceDetpack(ent) )
				{
					ps->stats[STAT_USEABLE_PLACED] = 1;
					trap_SendServerCommand( ent-g_entities, "cp \"CHARGE PLACED\"" );
				}
				else
				{//couldn't place it
					ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable( HI_DETPACK ) - bg_itemlist);
					trap_SendServerCommand( ent-g_entities, "cp \"NO ROOM TO PLACE CHARGE\"" );
				}
			}
			else
			{
				//turn off invincibility since you are going to do massive damage
				//ps->powerups[PW_GHOST] = 0;//NOTE: this means he can respawn and get a detpack 10 seconds later
				// ok, we placed it earlier. blow it up.
				ps->stats[STAT_USEABLE_PLACED] = 0;
				DetonateDetpack(ent);
			}
			break;

		case EV_USE_ITEM4:		// portable shield
			if ( !PlaceShield(ent) )	// fixme if we fail, perhaps just spawn it as a pickup
			{//couldn't place it
				ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable( HI_SHIELD ) - bg_itemlist);
				trap_SendServerCommand( ent-g_entities, "cp \"NO ROOM TO PLACE FORCE FIELD\"" );
			}
			else
			{
				trap_SendServerCommand( ent-g_entities, "cp \"FORCE FIELD PLACED\"" );
				//if ( client->sess.sessionClass == PC_ADMIN )
			//	{
				//	client->teleportTime = level.time + ( 30 * 1000 );
				//	ps->stats[STAT_USEABLE_PLACED] = 30;
				//}
			}
			break;

		case EV_USE_ITEM5:		// decoy
			if ( !PlaceDecoy(ent) )
			{//couldn't place it
				ps->stats[STAT_HOLDABLE_ITEM] = (BG_FindItemForHoldable( HI_DECOY ) - bg_itemlist);
				trap_SendServerCommand( ent-g_entities, "cp \"NO ROOM TO PLACE DECOY\"" );
			}
			else
			{
				trap_SendServerCommand( ent-g_entities, "cp \"DECOY PLACED\"" );
			}
			break;

		default:
			break;
		}
	}

}

void BotTestSolid(vec3_t origin);

/*
=============
ThrowWeapon

RPG-X
Marcin 03/12/2008
=============
*/
/**
*	Throw a weapon away.
*	\author Ubergames - Marcin
*	\date 03/12/2008
*/
void ThrowWeapon( gentity_t *ent, char *txt )
{
	gclient_t	*client;
	usercmd_t	*ucmd;
	gitem_t		*item;
	gentity_t	*drop;
	byte i;
	playerState_t *ps;

	client = ent->client;
	ucmd = &ent->client->pers.cmd;
	ps = &client->ps;

    if ( rpg_allowWeaponDrop.integer == 0) {
        return;
    }

	if ( numTotalDropped >= MAX_DROPPED ) {
		WARNING(("RPG-X Warning: maximum of dropped items of %i reached.\n", MAX_DROPPED));
		return;
	}

    if ( ps->weapon == WP_1 || ( ucmd->buttons & BUTTON_ATTACK )) {
		return;
    }

	numTotalDropped++;

	item = BG_FindItemForWeapon( ps->weapon );

    // admins don't lose weapon when thrown
    if ( IsAdmin( ent ) == qfalse ) {
		ps->ammo[ ps->weapon ] -= 1;
		if (ps->ammo[ ps->weapon ] <= 0) {
			ps->stats[STAT_WEAPONS] &= ~( 1 << ps->weapon );
			ps->weapon = WP_1;
			for ( i = WP_NUM_WEAPONS - 1 ; i > 0 ; i-- ) {
				if ( ps->stats[STAT_WEAPONS] & ( 1 << i ) ) {
					ps->weapon = i;
					break;
				}
			}
		}
    }

	drop = DropWeapon( ent, item, 0, FL_DROPPED_ITEM | FL_THROWN_ITEM, txt );
    drop->parent = ent;
	drop->count = 1;
}


/*
==============
SendPendingPredictableEvents
==============
*/
void SendPendingPredictableEvents( playerState_t *ps ) {
	gentity_t *t;
	int event, seq;
	int extEvent;

	// if there are still events pending
	if ( ps->entityEventSequence < ps->eventSequence ) {
		// create a temporary entity for this event which is sent to everyone
		// except the client generated the event
		seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
		event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
		// set external event to zero before calling BG_PlayerStateToEntityState
		extEvent = ps->externalEvent;
		ps->externalEvent = 0;
		// create temporary entity for event
		t = G_TempEntity( ps->origin, event );
		BG_PlayerStateToEntityState( ps, &t->s, qtrue );
		t->s.eType = ET_EVENTS + event;
		// send to everyone except the client who generated the event
		t->r.svFlags |= SVF_NOTSINGLECLIENT;
		t->r.singleClient = ps->clientNum;
		// set back external event
		ps->externalEvent = extEvent;
	}
}

void ClientCamThink(gentity_t *client) {
	if(!client->client->cam) return;
	G_SetOrigin(client, client->client->cam->s.origin);
	SetClientViewAngle(client, client->client->cam->s.angles);
	trap_LinkEntity(client);
}

/*
==============
ClientThink
==============
*/
/**
*	This will be called once for each client frame, which will
*	usually be a couple times for each server frame on fast clients.
*
*	If "g_synchronousClients 1" is set, this will be called exactly
*	once for each server frame, which makes for smooth demo recording.
*/
void ClientThink_real( gentity_t *ent ) {
	gclient_t	*client;
	pmove_t		pm;
	vec3_t		oldOrigin;
	int			oldEventSequence;
	int			msec;
	usercmd_t	*ucmd;
	playerState_t *ps;

	client = ent->client;
	ps = &client->ps;

	// don't think if the client is not yet connected (and thus not yet spawned in)
	if (client->pers.connected != CON_CONNECTED) {
		return;
	}
	// mark the time, so the connection sprite can be removed
	ucmd = &client->pers.cmd;

	// sanity check the command time to prevent speedup cheating
	if ( ucmd->serverTime > level.time + 200 ) {
		ucmd->serverTime = level.time + 200;
//		G_Printf("serverTime <<<<<\n" );
	}
	if ( ucmd->serverTime < level.time - 1000 ) {
		ucmd->serverTime = level.time - 1000;
//		G_Printf("serverTime >>>>>\n" );
	}

	msec = ucmd->serverTime - ps->commandTime;
	// following others may result in bad times, but we still want
	// to check for follow toggles
	if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW ) {
		return;
	}
	if ( msec > 200 ) {
		msec = 200;
	}

	//
	// check for exiting intermission
	//
	if ( level.intermissiontime ) {
		ClientIntermissionThink( client );
		return;
	}

	if (ent->flags & FL_CCAM) {
		ClientCamThink( ent );
		return;
	}

	// Don't move while under intro sequence.
	/*if (ps->introTime > level.time)
	{	// Don't be visible either.
		ent->s.eFlags |= EF_NODRAW;
		SetClientViewAngle( ent, ent->s.angles );
		ucmd->buttons = 0;
		ucmd->weapon = 0;
//		ucmd->angles[0] = ucmd->angles[1] = ucmd->angles[2] = 0;
		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
//		return;
	}*/

	// spectators don't do much
	if ( client->sess.sessionTeam == TEAM_SPECTATOR /*|| (ps->eFlags&EF_ELIMINATED) */) {
		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
			return;
		}
		SpectatorThink( ent, ucmd );
		return;
	}

	// check for inactivity timer, but never drop the local client of a non-dedicated server
	if ( !ClientInactivityTimer( client ) ) {
		return;
	}

	//TiM - If we're null content... see what's up
	if ( ent->r.contents == CONTENTS_NONE ) {
		if ( !G_MoveBox( ent ) ) {
			if ( ps->stats[STAT_HEALTH] > 1 )
				ent->r.contents = CONTENTS_BODY;
			else
				ent->r.contents = CONTENTS_CORPSE;
		}
		//else {
		//	ent->r.contents = CONTENTS_NONE;
		//}
	}

	// clear the rewards if time
	/*if ( level.time > client->rewardTime ) {
		ps->eFlags &= ~EF_AWARD_MASK;
	}*/
	
	//RPG-X: Checked to see if medics revive is on if so do as following
	if(rpg_medicsrevive.integer == 1){
		if ( client->noclip ) {
			ps->pm_type = PM_NOCLIP;
		} else if ( ps->stats[STAT_HEALTH] == 1 ) {
			ps->pm_type = PM_DEAD;
		} else {
			ps->pm_type = PM_NORMAL;
		}
	}else{
		if ( client->noclip ) {
			ps->pm_type = PM_NOCLIP;
		} else if ( ps->stats[STAT_HEALTH] <= 0 ) {
			ps->pm_type = PM_DEAD;
		} else {
			ps->pm_type = PM_NORMAL;
		}
	}
	
	//RPG-X: J2J & Phenix - For the gravity ent
	if(client->SpecialGrav != qtrue)
	{
		ps->gravity = g_gravity.value;
	}

	// set speed
	ps->speed = g_speed.value;

	if ( ps->powerups[PW_HASTE] )
	{
		ps->speed *= 1.5;
	}
	else if (ps->powerups[PW_FLIGHT] )
	{//flying around
		ps->speed *= 1.3;
	}
	else if ( ps->stats[STAT_HEALTH] <= 20 ) {
		ps->speed *= 0.55;
	}
	
	if (( ps->powerups[PW_EVOSUIT] ) && ( ps->gravity == 0 ))
	{//Evosuit time.. RPG-X | Phenix | 8/8/2004
		ps->speed *= 1.3;
	}
	
	//RPG-X: Redtechie - n00bie stay.....good boy!
	if ( g_classData[client->sess.sessionClass].isn00b /*client->sess.sessionClass == PC_N00B*/ ){
     ps->speed = 0;
	}

	/*if ( client->sess.sessionClass == PC_HEAVY )
	{
		ps->speed *= 0.75;
	}

	if ( client->sess.sessionClass == PC_BORG )
	{
		if ( BG_BorgTransporting( &client->ps ) )
		{
			ps->speed *= 1.5;
		}
		else if ( !BG_BorgTransporting( &client->ps ) )
		{
			ps->speed *= 0.75;
		}
	}*/

	//TiM : SP Style Transporter. :)
	//first check to see if we should be beaming
	if ( level.time < TransDat[ps->clientNum].beamTime ) {

		//if we're past the mid point of each materialization cycle, make it
		//so bullets and other players will pass thru the transportee. :)
		if ( (level.time > TransDat[ps->clientNum].beamTime - 6000) &&
			( level.time < TransDat[ps->clientNum].beamTime - 2000 ) ) {
			if ( ps->stats[STAT_HEALTH] > 1 ) {
				ent->r.contents = CONTENTS_NONE;
			}
			//ent->r.contents = CONTENTS_CORPSE;
		}
		else {
			if ( ps->stats[STAT_HEALTH] > 1 ) {
				ent->r.contents = MASK_PLAYERSOLID;
				//ent->r.contents = CONTENTS_BODY;
			}
		}

		//If we're half-way thru the cycle, teleport the player now
		if ( level.time > TransDat[ps->clientNum].beamTime - 4000 && 
		!TransDat[ps->clientNum].beamed ) {
			TeleportPlayer( ent, TransDat[ps->clientNum].currentCoord.origin, 
									TransDat[ps->clientNum].currentCoord.angles, 
									TP_TRI_TP );

			TransDat[ps->clientNum].beamed = qtrue;
		}
	}
	else {
		//all done, let's reset :)
		if ( TransDat[ps->clientNum].beamTime > 0 ) {
			TransDat[ps->clientNum].beamTime = 0;
			ps->powerups[PW_BEAM_OUT] = 0;
			ps->powerups[PW_QUAD] = 0;
			TransDat[ps->clientNum].beamed = qfalse;

			memset( &TransDat[ps->clientNum].currentCoord, 0, 
					sizeof( TransDat[ps->clientNum].currentCoord.origin ) );

			if(g_entities[ps->clientNum].flags & FL_CLAMPED) {
				//reset everything if player was beamed by trigger_transporter
				g_entities[ps->clientNum].flags ^= FL_CLAMPED;
			}
		}
	}

	//TiM : Freeze their movement if they're halfway through a transport cycle
	if ( level.time < TransDat[ps->clientNum].beamTime && 
		level.time > TransDat[ps->clientNum].beamTime - 4000 )
	{
		vec3_t	endPoint;
		trace_t	tr;
		VectorSet( endPoint, ps->origin[0], ps->origin[1], ps->origin[2] - 48 );
		//Do a trace down.  If we're near ground, just re-enable gravity.  Else we we get weird animations O_o
		trap_Trace( &tr, ps->origin, NULL, NULL, endPoint, ps->clientNum, CONTENTS_SOLID );

		if ( tr.fraction == 1.0 ) {
			ps->gravity = 0;
			ps->velocity[2] = 0;
		}

		ps->speed = 0;
		
		ps->velocity[0] = ps->velocity[1] = 0.0;
	}

	// set up for pmove
	oldEventSequence = ps->eventSequence;

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

	pm.ps = &client->ps;
	pm.cmd = *ucmd;
	if ( pm.ps->pm_type == PM_DEAD ) {
		pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
	}
	else {
		pm.tracemask = MASK_PLAYERSOLID;
	}

	pm.trace = trap_Trace;
	pm.pointcontents = trap_PointContents;
	pm.debugLevel = g_debugMove.integer;
	pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
	pm.pModDisintegration = g_pModDisintegration.integer > 0;

	//pm.admin = IsAdmin(ent); // we use this way now the old way didn't work for adminlogin
	// y call a function though???
	pm.admin = g_classData[client->sess.sessionClass].isAdmin || client->LoggedAsAdmin;
	//pm.admin = g_classData[client->sess.sessionClass].isAdmin;
	pm.medic = g_classData[client->sess.sessionClass].isMedical;
	pm.borg	 = g_classData[client->sess.sessionClass].isBorg;

	VectorCopy( ps->origin, oldOrigin );

	// perform a pmove
	Pmove (&pm);

	// save results of pmove
	if ( ps->eventSequence != oldEventSequence ) {
		ent->eventTime = level.time;
	}
	BG_PlayerStateToEntityState( ps, &ent->s, qtrue );

	SendPendingPredictableEvents( ps );

	// use the snapped origin for linking so it matches client predicted versions
	VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );

	VectorCopy (pm.mins, ent->r.mins);
	VectorCopy (pm.maxs, ent->r.maxs);

	ent->waterlevel = pm.waterlevel;
	ent->watertype = pm.watertype;

	// execute client events
	ClientEvents( ent, oldEventSequence );

	if ( pm.useEvent )
	{		//TODO: Use
		TryUse( ent );
	}

	// link entity now, after any personal teleporters have been used
	trap_LinkEntity (ent);
//	if ( !client->noclip ) {
		G_TouchTriggers( ent );
//	}

	// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
	VectorCopy( ps->origin, ent->r.currentOrigin );

	//test for solid areas in the AAS file
	BotTestSolid(ent->r.currentOrigin);

	// touch other objects
	ClientImpacts( ent, &pm );

	// save results of triggers and client events
	if (ps->eventSequence != oldEventSequence) {
		ent->eventTime = level.time;
	}

	// swap and latch button actions
	client->oldbuttons = client->buttons;
	client->buttons = ucmd->buttons;
	client->latched_buttons |= client->buttons & ~client->oldbuttons;

	// check for respawning
	if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
		// wait for the attack button to be pressed
		if ( level.time > client->respawnTime ) {
			// forcerespawn is to prevent users from waiting out powerups
			//RPG-X: RedTechie - No forcerespawn
			/*if ( g_forcerespawn.integer > 0 &&
				( level.time - client->respawnTime ) > g_forcerespawn.integer * 1000 ) {
				respawn( ent );
				return;
			}*/

			// pressing attack or use is the normal respawn method
			if ( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) ) {
				respawn( ent );
				return;
			}

			//in assimilation and elimination, always force respawn
			/*if ( level.time - client->respawnTime > 1300 && //NOTE: when killed, client->respawnTime = level.time + 1700, so this is 3000 ms
				( g_pModAssimilation.integer || g_pModElimination.integer ) )
			{
				respawn( ent );
				return;
			}*/
		}
		return;
	}

	// perform once-a-second actions
	ClientTimerActions( ent, msec );

	if ( client->teleportTime > 0 && client->teleportTime < level.time )
	{
		//if ( client->sess.sessionClass == PC_BORG )
		//{
		//	if ( BG_BorgTransporting( ps ) )
		//	{
		//		G_Rematerialize( ent );
		//	}
		//	else
		//	{
		//		G_GiveHoldable( client, HI_TRANSPORTER );
		//		ps->stats[STAT_USEABLE_PLACED] = 0;
		//		client->teleportTime = 0;
		//	}
		//}
		//else if ( client->sess.sessionClass == PC_DEMO )
		//{
		//	G_GiveHoldable( client, HI_DETPACK );
		//	ps->stats[STAT_USEABLE_PLACED] = 0;
		//	client->teleportTime = 0;
		//}
		/*else */if ( g_classData[client->sess.sessionClass].isMarine /*client->sess.sessionClass == PC_ALPHAOMEGA22*/ )
		{
			G_GiveHoldable( client, HI_TRANSPORTER );
			ps->stats[STAT_USEABLE_PLACED] = 0;
			client->teleportTime = 0;
		}
		else if ( g_classData[client->sess.sessionClass].isAdmin /*client->sess.sessionClass == PC_ADMIN*/ )
		{
			G_GiveHoldable( client, HI_SHIELD );
			ps->stats[STAT_USEABLE_PLACED] = 0;
			client->teleportTime = 0;
		}
	}

}

/*
==================
ClientThink

==================
*/
/**
*	A new command has arrived from the client
*/
void ClientThink( int clientNum ) {
	gentity_t *ent;

	ent = g_entities + clientNum;
	trap_GetUsercmd( clientNum, &ent->client->pers.cmd );

	// mark the time we got info, so we can display the
	// phone jack if they don't get any for a while
	ent->client->lastCmdTime = level.time;

	if ( !g_synchronousClients.integer ) {
		ClientThink_real( ent );
	}
}


void G_RunClient( gentity_t *ent ) {
	if ( !g_synchronousClients.integer ) {
		return;
	}
	ent->client->pers.cmd.serverTime = level.time;
	ClientThink_real( ent );
}


/*
==================
SpectatorClientEndFrame

==================
*/
void SpectatorClientEndFrame( gentity_t *ent ) {
	gclient_t	*cl;
	clientSession_t *sess = &ent->client->sess;
	playerState_t *ps = &ent->client->ps;

	// if we are doing a chase cam or a remote view, grab the latest info
	if ( sess->spectatorState == SPECTATOR_FOLLOW ) {
		int		clientNum;

		clientNum = 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 ) {
			cl = &level.clients[ clientNum ];
			if ( cl->pers.connected == CON_CONNECTED && cl->sess.sessionTeam != TEAM_SPECTATOR ) {
				ent->client->ps = cl->ps;
				ps->pm_flags |= PMF_FOLLOW;
				return;
			} else {
				// drop them to free spectators unless they are dedicated camera followers
				if ( sess->spectatorClient >= 0 ) {
					sess->spectatorState = SPECTATOR_FREE;
					ClientBegin( ent->client - level.clients, qfalse, qfalse, qfalse );
				}
			}
		}
	}

	if ( sess->spectatorState == SPECTATOR_SCOREBOARD ) {
		ps->pm_flags |= PMF_SCOREBOARD;
	} else {
		ps->pm_flags &= ~PMF_SCOREBOARD;
	}
}

/*
==============
ClientEndFrame
==============
*/
/**
*	Called at the end of each server frame for each connected client
*	A fast client will have multiple ClientThink for each ClientEdFrame,
*	while a slow client may have multiple ClientEndFrame between ClientThink.
*/
void ClientEndFrame( gentity_t *ent ) {
	int			i;
	clientPersistant_t	*pers;
	playerState_t *ps = &ent->client->ps;

	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR /*|| (ps->eFlags&EF_ELIMINATED)*/ ) {
		SpectatorClientEndFrame( ent );
		ent->client->noclip = qtrue;
		return;
	}

	pers = &ent->client->pers;

	// turn off any expired powerups
	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
		if ( ps->powerups[ i ] < level.time ) {
			ps->powerups[ i ] = 0;
		}
	}

	// save network bandwidth
#if 0
	if ( !g_synchronousClients->integer && ps->pm_type == PM_NORMAL ) {
		// FIXME: this must change eventually for non-sync demo recording
		VectorClear( ps->viewangles );
	}
#endif

	//
	// If the end of unit layout is displayed, don't give
	// the player any normal movement attributes
	//
	if ( level.intermissiontime ) {
		return;
	}

	// burn from lava, etc
	P_WorldEffects (ent);

	// apply all the damage taken this frame
	P_DamageFeedback (ent);

	// add the EF_CONNECTION flag if we haven't gotten commands recently
	if ( level.time - ent->client->lastCmdTime > 1000 ) {
		ent->s.eFlags |= EF_CONNECTION;
	} else {
		ent->s.eFlags &= ~EF_CONNECTION;
	}

	ps->stats[STAT_HEALTH] = ent->health;	// FIXME: get rid of ent->health...

	G_SetClientSound (ent);

	// set the latest infor
	BG_PlayerStateToEntityState( ps, &ent->s, qtrue );
	SendPendingPredictableEvents( ps );

}