Binary files et.orig/src/game/.g_antilag.c.swp and etpub/src/game/.g_antilag.c.swp differ
diff -urN --exclude=.svn et.orig/src/game/bg_animation.c etpub/src/game/bg_animation.c
--- et.orig/src/game/bg_animation.c	2003-05-03 06:50:52.000000000 -0500
+++ etpub/src/game/bg_animation.c	2005-03-15 17:54:19.000000000 -0600
@@ -1422,6 +1422,7 @@
 	animScriptItem_t	*scriptItem = NULL;
 	animScriptCommand_t	*scriptCommand = NULL;
 	int					state = ps->aiState;
+	qboolean setTimer = qfalse;
 
 	// Allow fallen movetype while dead
 	if( ps->eFlags & EF_DEAD && movetype != ANIM_MT_FALLEN && movetype != ANIM_MT_FLAILING )
@@ -1466,9 +1467,25 @@
 		Com_Printf( "anim1 (%s): %s", animBodyPartsStr[scriptCommand->bodyPart[1]].string, animModelInfo->animations[scriptCommand->animIndex[1]]->name );
 	Com_Printf( "\n" );
 #endif
+	// tjw: this is a dirty dirty hack and should be removed
+	//      if using a client mod (update the animation script).
+	//      This is here because I added head hitboxes to 
+	//      corpses and we can't have their heads leaving the 
+	//      ground because the hitboxes can't do that.  
+	if(movetype == ANIM_MT_FALLEN) {
+		setTimer = qtrue;
+		if(ps->torsoTimer < 3400) 
+			return( BG_ExecuteCommand(ps,
+				animModelInfo,
+				scriptCommand,
+				setTimer,
+				qfalse,
+				qtrue) != -1 );
+
+	}
 
 	// run it
-	return( BG_ExecuteCommand( ps, animModelInfo, scriptCommand, qfalse, isContinue, qfalse ) != -1 );
+	return( BG_ExecuteCommand( ps, animModelInfo, scriptCommand, setTimer, isContinue, qfalse ) != -1 );
 }
 
 /*
diff -urN --exclude=.svn et.orig/src/game/bg_local.h etpub/src/game/bg_local.h
--- et.orig/src/game/bg_local.h	2003-04-14 17:32:26.000000000 -0500
+++ etpub/src/game/bg_local.h	2005-02-14 12:52:55.000000000 -0600
@@ -75,3 +75,7 @@
 void		PM_StepSlideMoveProne( qboolean gravity );
 
 void PM_BeginWeaponChange( int oldweapon, int newweapon, qboolean reload );
+
+// tjw
+extern vmCvar_t g_weapons;
+extern vmCvar_t g_spinCorpse;
diff -urN --exclude=.svn et.orig/src/game/bg_misc.c etpub/src/game/bg_misc.c
--- et.orig/src/game/bg_misc.c	2003-08-28 15:43:22.000000000 -0500
+++ etpub/src/game/bg_misc.c	2005-03-16 10:55:34.000000000 -0600
@@ -13,12 +13,17 @@
 #ifdef CGAMEDLL
 	extern	vmCvar_t cg_gameType;
 #define gametypeCvar cg_gameType
+#define MISC_UW_AMMO_RESTORES_HELMET 0 // josh: no client mod
 #elif GAMEDLL
 	extern	vmCvar_t g_developer;
 	extern	vmCvar_t g_gametype;
 #define gametypeCvar g_gametype
+  extern vmCvar_t g_weapons;
+#define MISC_UW_AMMO_RESTORES_HELMET \
+    (g_weapons.integer & WPF_AMMO_RESTORES_HELMET)
 #else
 	extern	vmCvar_t ui_gameType;
+#define MISC_UW_AMMO_RESTORES_HELMET 0 // josh: no ui stuff here
 #define gametypeCvar ui_gameType
 #endif
 
@@ -153,7 +158,7 @@
 	{	90,				1,		30,		30,		30,		2400,	DELAY_LOW,		150,	0,		0,		MOD_THOMPSON			},	// WP_THOMPSON				// 8
 	{	45,				1,		15,		0,		4,		1000,	DELAY_THROW,	1600,	0,		0,		MOD_GRENADE_PINEAPPLE	},	// WP_GRENADE_PINEAPPLE		// 9
 
-	{	96,				1,		32,		32,		32,		3100,	DELAY_LOW,		150,	1200,	450,	MOD_STEN				},	// WP_STEN					// 10
+	{	96,				1,		32,		64,		32,		3100,	DELAY_LOW,		150,	1200,	450,	MOD_STEN				},	// WP_STEN					// 10
 	{	10,				1,		1,		0,		10,		1500,	50,				1000,	0,		0,		MOD_SYRINGE				},	// WP_MEDIC_SYRINGE			// 11
 	{	1,				0,		1,		0,		0,		3000,	50,				1000,	0,		0,		MOD_AMMO,				},	// WP_AMMO					// 12
 	{	1,				0,		1,		0,		1,		3000,	50,				1000,	0,		0,		MOD_ARTY,				},	// WP_ARTY					// 13												
@@ -2908,6 +2913,15 @@
 	int			clip;
 	int			weapNumOfClips;
 
+	// Michael:  add the helmet first, then do weapons
+	// it looks like the way to check if they have a helmet is by 
+	// seeing if they have already been shot in the head
+	// to add the helmet, just clear the bit
+	if(MISC_UW_AMMO_RESTORES_HELMET && (ps->eFlags & EF_HEADSHOT)) {
+		ps->eFlags &= (EF_HEADSHOT ^ 0xFFFFFFFF);
+	}
+
+
 	// Gordon: handle grenades first
 	i = BG_GrenadesForClass( ps->stats[STAT_PLAYER_CLASS], skill );
 	weapon = BG_GrenadeTypeForTeam( teamNum );
@@ -4027,9 +4041,11 @@
 
 	s->eFlags = ps->eFlags;
 
-	if ( ps->stats[STAT_HEALTH] <= 0 ) {
+	if(ps->stats[STAT_HEALTH] <= 0 &&
+		!(ps->eFlags & EF_PLAYDEAD)) {
 		s->eFlags |= EF_DEAD;
-	} else {
+	} 
+	else {
 		s->eFlags &= ~EF_DEAD;
 	}
 
@@ -4128,9 +4144,11 @@
 	}
 
 	s->eFlags = ps->eFlags;
-	if ( ps->stats[STAT_HEALTH] <= 0 ) {
+	if(ps->stats[STAT_HEALTH] <= 0 &&
+		!(ps->eFlags & EF_PLAYDEAD)) {
 		s->eFlags |= EF_DEAD;
-	} else {
+	} 
+	else {
 		s->eFlags &= ~EF_DEAD;
 	}
 
diff -urN --exclude=.svn et.orig/src/game/bg_pmove.c etpub/src/game/bg_pmove.c
--- et.orig/src/game/bg_pmove.c	2003-08-28 15:43:22.000000000 -0500
+++ etpub/src/game/bg_pmove.c	2005-03-16 13:27:16.000000000 -0600
@@ -15,8 +15,14 @@
 
 #ifdef CGAMEDLL
 #define PM_GameType cg_gameType.integer
+#define PM_UW_SYRINGE 0 // tjw: no client mod
+#define PM_UW_PLIERS 0 // tjw: no client mod
+#define PM_CORPSE_SPIN 0 // tjw: no client mod
 #elif GAMEDLL
 #define PM_GameType g_gametype.integer
+#define PM_UW_SYRINGE (g_weapons.integer & WPF_UNDERWATER_SYRINGE)
+#define PM_UW_PLIERS (g_weapons.integer & WPF_UNDERWATER_PLIERS)
+#define PM_CORPSE_SPIN g_spinCorpse.integer
 #endif
 
 #define PM_IsSinglePlayerGame() (PM_GameType == GT_SINGLE_PLAYER || PM_GameType == GT_COOP)
@@ -727,6 +733,145 @@
 	return qtrue;
 }
 
+
+/*
+ * PM_CheckPlayDead
+ * see if this player can lay down and look dead
+*/
+static qboolean PM_CheckPlayDead (void)
+{
+	vec3_t org, flatforward, point;
+	trace_t trace;
+
+	if(pm->ps->pm_type != PM_PLAYDEAD) return qfalse;
+
+	// PM_PLAYDEAD is a one time only pm_type
+	pm->ps->pm_type = PM_NORMAL;
+
+	if(!(pm->ps->eFlags & EF_PLAYDEAD)) {
+		if(pm->ps->pm_flags & PMF_LADDER) {
+			return qfalse;
+		}
+
+		if(pm->ps->persistant[PERS_HWEAPON_USE] || 
+			pm->ps->eFlags & EF_MOUNTEDTANK) {
+
+			return qfalse;
+		}
+
+		if(pm->waterlevel > 1) {
+			return qfalse;
+		}
+
+		// see if we have the space to go prone
+		// we know our main body isn't in a solid, check for our legs
+		flatforward[0] = pml.forward[0];
+		flatforward[1] = pml.forward[1];
+		flatforward[2] = 0;
+
+		org[0] = pm->ps->origin[0] + flatforward[0] * -32;
+		org[1] = pm->ps->origin[1] + flatforward[1] * -32;
+		org[2] = pm->ps->origin[2] + 24.f;	// 24 units to play with
+
+		// diff between playerlegsMins and playerlegsMaxs z + 24 units to play with
+		VectorSet( point, org[0], org[1], org[2] - ( 24.f - 2.4f ) - 24.f );	
+
+		pm->trace (&trace, 
+			org, 
+			playerlegsProneMins, 
+			playerlegsProneMaxs, 
+			point, 
+			pm->ps->clientNum, 
+			pm->tracemask);
+
+		if( trace.startsolid && trace.entityNum >= MAX_CLIENTS ) {
+			// starting in a solid, no prone at all
+			return qfalse;
+		} 
+		else if( trace.fraction == 1.f ) {
+			// no ground to play dead on, so don't
+			return qfalse;
+		} 
+		VectorCopy( trace.endpos, org );
+		VectorSet( point, org[0], org[1], org[2] + ( 24.f - 2.4f ) );
+
+		pm->trace (&trace, 
+			org, 
+			playerlegsProneMins, 
+			playerlegsProneMaxs, 
+			point, 
+			pm->ps->clientNum, 
+			pm->tracemask);
+
+		if (!trace.allsolid || trace.entityNum < MAX_CLIENTS) {
+			pm->ps->eFlags |= EF_PLAYDEAD;
+			pm->ps->eFlags |= EF_DEAD;
+			pm->ps->pm_type = PM_DEAD;
+
+			// client uses stats[STAT_HEALTH] as the indicator for 
+			// revive sprites and player position 
+			pm->ps->stats[STAT_HEALTH] = 0;
+
+			// make the hitbox like a dead guy
+			pm->maxs[2] = pm->ps->maxs[2] = pm->ps->crouchMaxZ;
+			return qtrue;
+		}
+	}
+	else {
+		// see if we have the space to stop playing dead
+		pm->mins[0] = pm->ps->mins[0];
+		pm->mins[1] = pm->ps->mins[1];
+
+		pm->maxs[0] = pm->ps->maxs[0];
+		pm->maxs[1] = pm->ps->maxs[1];
+
+		pm->mins[2] = pm->ps->mins[2];
+		pm->maxs[2] = pm->ps->crouchMaxZ;
+
+		pm->trace( &trace, 
+			pm->ps->origin, 
+			pm->mins, 
+			pm->maxs, 
+			pm->ps->origin, 
+			pm->ps->clientNum, 
+			pm->tracemask );
+
+		if(trace.allsolid) {
+			// this would have been turned up to ent->health
+			// before running a PM_PLAYDEAD.  Set it back down 
+			// if we can't stand up.
+			pm->ps->stats[STAT_HEALTH] = 0;
+			return qfalse;
+		}
+
+		// crouch for a bit
+		pm->ps->pm_flags |= PMF_DUCKED;
+
+		// turn the hitbox back up	
+		pm->maxs[2] = pm->ps->maxs[2] = pm->ps->standViewHeight;
+
+		// stop playdead
+		pm->ps->eFlags &= ~EF_PLAYDEAD;
+		pm->ps->eFlags &= ~EF_DEAD;
+
+		// this is need to force the end of the fallen animation
+		// because of the timer hack in bg_animation.c
+		pm->ps->torsoTimer = 0;
+		BG_AnimScriptEvent(pm->ps,
+			pm->character->animModelInfo,
+			ANIM_ET_JUMPBK,
+			qfalse,
+			qtrue);
+
+		// don't jump for a bit
+		pm->pmext->jumpTime = pm->cmd.serverTime - 650;
+		pm->ps->jumpTime = pm->cmd.serverTime - 650;
+		
+		return qtrue;
+	}
+	return qfalse;
+}
+
 /*
 ==============
 PM_CheckProne
@@ -772,11 +917,13 @@
 		//	return qfalse;
 		//}
 
-		if( ((pm->ps->pm_flags & PMF_DUCKED && pm->cmd.doubleTap == DT_FORWARD) ||
-			(pm->cmd.wbuttons & WBUTTON_PRONE)) && pm->cmd.serverTime - -pm->pmext->proneTime > 750  ) {
+		if(((pm->ps->pm_flags & PMF_DUCKED && 
+			pm->cmd.doubleTap == DT_FORWARD) ||
+			(pm->cmd.wbuttons & WBUTTON_PRONE)) && 
+			pm->cmd.serverTime - -pm->pmext->proneTime > 750) {
+
 			vec3_t org, flatforward, point;
 			trace_t trace;
-
 			// see if we have the space to go prone
 			// we know our main body isn't in a solid, check for our legs
 			flatforward[0] = pml.forward[0];
@@ -812,6 +959,7 @@
 					pm->ps->eFlags |= EF_PRONE;
 					pm->pmext->proneTime = pm->cmd.serverTime;	// timestamp 'go prone'
 					pm->pmext->proneGroundTime = pm->cmd.serverTime;
+					pm->maxs[2] = pm->ps->crouchMaxZ;
 				}
 			}
 		}
@@ -822,7 +970,11 @@
 			pm->ps->pm_type == PM_DEAD ||
 			pm->ps->eFlags & EF_MOUNTEDTANK ||
 			pm->cmd.serverTime - pm->pmext->proneGroundTime > 450 ||
-			((pm->cmd.doubleTap == DT_BACK || pm->cmd.upmove > 10 || pm->cmd.wbuttons & WBUTTON_PRONE) && pm->cmd.serverTime - pm->pmext->proneTime > 750) ) {
+			((pm->cmd.doubleTap == DT_BACK || 
+			  pm->cmd.upmove > 10 || 
+			  pm->cmd.wbuttons & WBUTTON_PRONE) 
+			 && pm->cmd.serverTime - pm->pmext->proneTime > 750)) {
+
 			trace_t trace;
 
 			// see if we have the space to stop prone
@@ -833,7 +985,6 @@
 			pm->maxs[1] = pm->ps->maxs[1];
 
 			pm->mins[2] = pm->ps->mins[2];
-			pm->maxs[2] = pm->ps->crouchMaxZ;
 
 			pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
 			if( !trace.allsolid ) {
@@ -887,9 +1038,12 @@
 		//if( frac > 1.f )
 		//	frac = 1.f;
 
-		//pm->maxs[2] = pm->ps->maxs[2] - (frac * (pm->ps->standViewHeight - PRONE_VIEWHEIGHT));
-		//pm->ps->viewheight = DEFAULT_VIEWHEIGHT - (frac * (DEFAULT_VIEWHEIGHT - PRONE_VIEWHEIGHT));	// default - prone to get a positive which is subtracted from default
-		pm->maxs[2] = pm->ps->maxs[2] - pm->ps->standViewHeight - PRONE_VIEWHEIGHT;
+ 
+		//pm->maxs[2] = pm->ps->maxs[2] - pm->ps->standViewHeight - PRONE_VIEWHEIGHT;
+		// tjw: it appears that 12 is the magic number 
+		//      for the minimum maxs[2] that prevents
+		//      player from getting stuck into the world.
+		pm->maxs[2] = 12;
 		pm->ps->viewheight = PRONE_VIEWHEIGHT;
 
 		return( qtrue );
@@ -1423,6 +1577,7 @@
 		VectorNormalize (pm->ps->velocity);
 		VectorScale (pm->ps->velocity, forward, pm->ps->velocity);
 	}
+
 }
 
 
@@ -1955,14 +2110,13 @@
 
 	if (pm->ps->eFlags & EF_DEAD) {
 
-
-		//if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
-		if ( pm->ps->pm_flags & PMF_FLAILING ) {
+		if( pm->ps->pm_flags & PMF_FLAILING ) {
 			animResult = BG_AnimScriptAnimation( pm->ps, pm->character->animModelInfo, ANIM_MT_FLAILING, qtrue );
 
 			if( !pm->ps->pm_time )
 				pm->ps->pm_flags &= ~PMF_FLAILING;	// the eagle has landed
-		} else if ( !pm->ps->pm_time && !(pm->ps->pm_flags & PMF_LIMBO) ) { // DHM - Nerve :: before going to limbo, play a wounded/fallen animation
+		} 
+		else if(!pm->ps->pm_time && !(pm->ps->pm_flags & PMF_LIMBO) ) { // DHM - Nerve :: before going to limbo, play a wounded/fallen animation
 			if ( pm->ps->groundEntityNum == ENTITYNUM_NONE ) {
 				// takeoff!
 				pm->ps->pm_flags |= PMF_FLAILING;
@@ -2925,6 +3079,7 @@
 */
 void PM_CoolWeapons( void ) {
 	int wp;
+	int maxHeat; // rain - for #172
 
 	for(wp=0;wp<WP_NUM_WEAPONS;wp++) {
 
@@ -2948,9 +3103,16 @@
 	// a weapon is currently selected, convert current heat value to 0-255 range for client transmission
 	if(pm->ps->weapon) {
 		if( pm->ps->persistant[PERS_HWEAPON_USE] || pm->ps->eFlags & EF_MOUNTEDTANK ) {
-			pm->ps->curWeapHeat = ( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f;
+			// rain - floor to prevent 8-bit wrap
+			pm->ps->curWeapHeat = floor( ( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f );
 		} else {
-			pm->ps->curWeapHeat = ( ( (float)pm->ps->weapHeat[pm->ps->weapon] / (float)GetAmmoTableData(pm->ps->weapon)->maxHeat) ) * 255.0f;
+			// rain - #172 - don't divide by 0
+			maxHeat = GetAmmoTableData(pm->ps->weapon)->maxHeat;
+			// rain - floor to prevent 8-bit wrap
+			if (maxHeat != 0)
+				pm->ps->curWeapHeat = floor( ( ( (float)pm->ps->weapHeat[pm->ps->weapon] / (float)maxHeat) ) * 255.0f);
+			else
+				pm->ps->curWeapHeat = 0;
 		}
 
 //		if(pm->ps->weapHeat[pm->ps->weapon])
@@ -3128,7 +3290,7 @@
 
 	// check for dead player
 	if ( pm->ps->stats[STAT_HEALTH] <= 0 ) {
-		if(!pm->ps->pm_flags & PMF_LIMBO) {
+		if(!(pm->ps->pm_flags & PMF_LIMBO)) {
 			PM_CoolWeapons();
 		}
 
@@ -3149,7 +3311,8 @@
 				if( pm->ps->weapHeat[WP_DUMMY_MG42] < 0 )
 					pm->ps->weapHeat[WP_DUMMY_MG42] = 0;
 
-				pm->ps->curWeapHeat = ( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f;
+				// rain - floor() to prevent 8-bit wrap
+				pm->ps->curWeapHeat = floor( ( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f );
 			}
 
 			if( pm->ps->weaponTime > 0 ) {
@@ -3211,7 +3374,11 @@
 			if( pm->ps->weapHeat[WP_DUMMY_MG42] < 0 )
 				pm->ps->weapHeat[WP_DUMMY_MG42] = 0;
 
-			pm->ps->curWeapHeat = ( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f;
+			// rain - floor() to prevent 8-bit wrap
+			//pm->ps->curWeapHeat = floor( ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) ) * 255.0f;
+			// tjw: reverse rain's fix since it always sets curWeapHeat to 0.
+			//      is 8-bit wrap even an issue here?
+			pm->ps->curWeapHeat = ( (float)pm->ps->weapHeat[WP_DUMMY_MG42] / MAX_MG42_HEAT) * 255.0f;
 		}
 
 		if( pm->ps->weaponTime > 0 ) {
@@ -3418,9 +3585,26 @@
 		if ( pm->ps->weapon == WP_LUGER || pm->ps->weapon == WP_COLT || pm->ps->weapon == WP_SILENCER || pm->ps->weapon == WP_SILENCED_COLT ||
 				pm->ps->weapon == WP_KAR98 || pm->ps->weapon == WP_K43 || pm->ps->weapon == WP_CARBINE || pm->ps->weapon == WP_GARAND ||
 				pm->ps->weapon == WP_GARAND_SCOPE || pm->ps->weapon == WP_K43_SCOPE || BG_IsAkimboWeapon( pm->ps->weapon ) ) {
+			// rain - bug #11 - this is wrong, the frame where BUTTON_ATTACK is up
+			// will eventually be outside of the pmove loop
+			// rain - XXX - reverted to this behavior: it seems that my other prediction
+			// fixes have made this work properly, and the other method is a frame
+			// or two behind. (#275)
+			// rain - moved releasedFire into pmext instead of ps
+			// tjw - left releasedFire in ps for now
+
 			if ( pm->ps->releasedFire ) {
-				if ( (pm->cmd.buttons & BUTTON_ATTACK) && pm->ps->weaponTime <= 150 ) {
-					pm->ps->weaponTime = 0;
+				if ( (pm->cmd.buttons & BUTTON_ATTACK) ) {
+					// rain - akimbo weapons only have a 200ms delay, so
+					// use a shorter time for quickfire (#255)
+
+					if (BG_IsAkimboWeapon(pm->ps->weapon)) {
+						if (pm->ps->weaponTime <= 50)
+							pm->ps->weaponTime = 0;
+					} else {
+						if (pm->ps->weaponTime <= 150)
+							pm->ps->weaponTime = 0;
+					}
 				}
 			} else if (!(pm->cmd.buttons & BUTTON_ATTACK)) {
 				pm->ps->releasedFire = qtrue;
@@ -3678,10 +3862,18 @@
 			pm->ps->weapon != WP_DYNAMITE &&
 			pm->ps->weapon != WP_LANDMINE &&
 			pm->ps->weapon != WP_TRIPMINE &&
-			pm->ps->weapon != WP_SMOKE_BOMB ) {
-				PM_AddEvent(EV_NOFIRE_UNDERWATER);	// event for underwater 'click' for nofire
+			pm->ps->weapon != WP_SMOKE_BOMB &&
+			!(pm->ps->weapon == WP_MEDIC_SYRINGE 
+				&& PM_UW_SYRINGE) &&
+			!(pm->ps->weapon == WP_PLIERS
+				&& PM_UW_PLIERS)
+			) {
+
+				// event for underwater 'click' for nofire
+				PM_AddEvent(EV_NOFIRE_UNDERWATER);
 				pm->ps->weaponTime	= 500;
-				pm->ps->weaponDelay	= 0;			// avoid insta-fire after water exit on delayed weapon attacks
+				// avoid insta-fire after water exit on delayed weapon attacks
+				pm->ps->weaponDelay	= 0;			
 				return;
 		}
 	}
@@ -4121,10 +4313,10 @@
 		addTime = GetAmmoTableData(pm->ps->weapon)->nextShotTime;
 
 		if( !pm->ps->ammoclip[BG_FindClipForWeapon(pm->ps->weapon)] ) {
-			if( akimboFire )
+			if( !akimboFire )
 				addTime = 2 * GetAmmoTableData(pm->ps->weapon)->nextShotTime;
 		} else if( !pm->ps->ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(pm->ps->weapon))] ) {
-			if( !akimboFire )
+			if( akimboFire )
 				addTime = 2 * GetAmmoTableData(pm->ps->weapon)->nextShotTime;
 		}
 
@@ -4474,7 +4666,14 @@
 		temp = cmd->angles[1] + ps->delta_angles[1];
 		if( ps->stats[STAT_DEAD_YAW] == 999 )
 			ps->stats[STAT_DEAD_YAW] = SHORT2ANGLE(temp);
-		return;		// no view changes at all
+		// tjw: don't let corpses bury their heads in the sand
+		ps->viewangles[2] = 0;
+		ps->viewangles[0] = 0;
+		if(PM_CORPSE_SPIN) {
+			temp = cmd->angles[1] + ps->delta_angles[1];
+			ps->viewangles[1] = SHORT2ANGLE(temp);
+		}
+		return;
 	}
 
 	VectorCopy( ps->viewangles, oldViewAngles );
@@ -4494,7 +4693,7 @@
 		}
 		ps->viewangles[i] = SHORT2ANGLE(temp);
 	}
-
+	
 	if( BG_PlayerMounted(ps->eFlags) ) {
 		float yaw, oldYaw;
 		float degsSec = MG42_YAWSPEED;
@@ -5090,7 +5289,6 @@
 				if( pm->skill[SK_BATTLE_SENSE] >= 2 )
 					rechargebase *= 1.6f;
 			}
-
 			pm->pmext->sprintTime += rechargebase*pml.frametime;		// JPW NERVE adjusted for framerate independence
 			if (pm->pmext->sprintTime > 5000)
 				pm->pmext->sprintTime += rechargebase*pml.frametime;	// JPW NERVE adjusted for framerate independence
@@ -5150,17 +5348,23 @@
 	pm->ps->eFlags &= ~(EF_FIRING | EF_ZOOMING);
 
 	if( pm->cmd.wbuttons & WBUTTON_ZOOM && pm->ps->stats[STAT_HEALTH] >= 0 && !( pm->ps->weaponDelay ) ) {
-		if(pm->ps->stats[STAT_KEYS] & (1<<INV_BINOCS)) {		// (SA) binoculars are an inventory item (inventory==keys)
-			if(!BG_IsScopedWeapon(pm->ps->weapon)) {	// don't allow binocs if using the sniper scope
-				if(!BG_PlayerMounted(pm->ps->eFlags)) {	// or if mounted on a weapon
-					pm->ps->eFlags |= EF_ZOOMING;
-				}
-			}
-
-			// don't allow binocs if in the middle of throwing grenade
-			if( (pm->ps->weapon == WP_GRENADE_LAUNCHER || pm->ps->weapon == WP_GRENADE_PINEAPPLE || pm->ps->weapon == WP_DYNAMITE) && pm->ps->grenadeTimeLeft > 0) {
-				pm->ps->eFlags &= ~EF_ZOOMING;
-			}
+		if(pm->ps->stats[STAT_KEYS] & (1<<INV_BINOCS)) {	// (SA) binoculars are an inventory item (inventory==keys)
+			if (!BG_IsScopedWeapon(pm->ps->weapon) &&		// don't allow binocs if using the sniper scope
+				!BG_PlayerMounted(pm->ps->eFlags) &&		// or if mounted on a weapon
+				// rain - don't allow binocs w/ mounted mob. MG42 or mortar
+				// either.
+				pm->ps->weapon != WP_MOBILE_MG42_SET &&	
+				pm->ps->weapon != WP_MORTAR_SET) {
+
+				pm->ps->eFlags |= EF_ZOOMING;
+			}
+		}
+		// don't allow binocs if in the middle of throwing grenade
+		if( (pm->ps->weapon == WP_GRENADE_LAUNCHER || 
+			pm->ps->weapon == WP_GRENADE_PINEAPPLE || 
+			pm->ps->weapon == WP_DYNAMITE) && 
+				pm->ps->grenadeTimeLeft > 0) {
+			pm->ps->eFlags &= ~EF_ZOOMING;
 		}
 	}
 
@@ -5315,14 +5519,14 @@
 		#endif
 	}
 
+
 	// set watertype, and waterlevel
 	PM_SetWaterLevel();
 	pml.previous_waterlevel = pmove->waterlevel;
 
+	PM_CheckPlayDead();
+
 	// set mins, maxs, and viewheight
-	//if( !PM_CheckProne() ) {
-//		PM_CheckDuck ();
-	//}
 	if( !PM_CheckProne() ) {
 		PM_CheckDuck();
 	}
@@ -5484,8 +5688,13 @@
 			}
 		}
 		else {
-			if ( msec > 66 ) {
-				msec = 66;
+			// rain - this was 66 (15fps), but I've changed it to
+			// 50 (20fps, max rate of mg42) to alleviate some of the
+			// framerate dependency with the mg42.
+			// in reality, this should be split according to sv_fps,
+			// and pmove() shouldn't handle weapon firing
+			if ( msec > 50 ) {
+				msec = 50;
 			}
 		}
 		pmove->cmd.serverTime = pmove->ps->commandTime + msec;
@@ -5496,6 +5705,12 @@
 		}
 	}
 
+	// rain - sanity check weapon heat
+	if (pmove->ps->curWeapHeat > 255)
+		pmove->ps->curWeapHeat = 255;
+	else if (pmove->ps->curWeapHeat < 0)
+		pmove->ps->curWeapHeat = 0;
+
 	//PM_CheckStuck();
 
 	if ( (pm->ps->stats[STAT_HEALTH] <= 0 || pm->ps->pm_type == PM_DEAD ) && pml.groundTrace.surfaceFlags & SURF_MONSTERSLICK )
diff -urN --exclude=.svn et.orig/src/game/bg_public.h etpub/src/game/bg_public.h
--- et.orig/src/game/bg_public.h	2003-06-23 14:13:46.000000000 -0500
+++ etpub/src/game/bg_public.h	2005-03-11 10:19:25.000000000 -0600
@@ -417,10 +417,11 @@
 typedef enum {
 	PM_NORMAL,		// can accelerate and turn
 	PM_NOCLIP,		// noclip movement
-	PM_SPECTATOR,	// still run into walls
+	PM_SPECTATOR,		// still run into walls
 	PM_DEAD,		// no acceleration or turning, but free falling
 	PM_FREEZE,		// stuck in place with no control
-	PM_INTERMISSION	// no movement or status bar
+	PM_INTERMISSION,	// no movement or status bar
+	PM_PLAYDEAD		// no movement or status bar
 } pmtype_t;
 
 typedef enum {
@@ -651,6 +652,7 @@
 #define	EF_BOUNCE_HALF		0x08000000		// for missiles
 #define	EF_MOVER_STOP		0x10000000		// will push otherwise	// (SA) moved down to make space for one more client flag
 #define EF_MOVER_BLOCKED	0x20000000		// mover was blocked dont lerp on the client // xkan, moved down to make space for client flag
+#define EF_PLAYDEAD		0x40000000  // player looks dead
 
 #define BG_PlayerMounted( eFlags ) (( eFlags & EF_MG42_ACTIVE ) || ( eFlags & EF_MOUNTEDTANK ) || ( eFlags & EF_AAGUN_ACTIVE ))
 
@@ -813,6 +815,15 @@
 							// NOTE: this cannot be larger than 64 for AI/player weapons!
 } weapon_t;
 
+#define WPF_NO_L0_FOPS_BINOCS		1 
+#define WPF_UNDERWATER_SYRINGE		2 
+#define WPF_UNDERWATER_PLIERS		4 
+#define WPF_TM_AIRSTRIKE_RESTORE_FULL	8 
+#define WPF_TM_AIRSTRIKE_RESTORE_HALF	16 
+#define WPF_AMMO_RESTORES_HELMET	32 
+#define WPF_DROP_BINOCS			64
+#define WPF_L4HW_KEEPS_PISTOL		128 
+
 // JPW NERVE moved from cg_weapons (now used in g_active) for drop command, actual array in bg_misc.c
 extern int weapBanksMultiPlayer[MAX_WEAP_BANKS_MP][MAX_WEAPS_IN_BANK_MP];
 // jpw
diff -urN --exclude=.svn et.orig/src/game/g_active.c etpub/src/game/g_active.c
--- et.orig/src/game/g_active.c	2003-08-26 16:20:40.000000000 -0500
+++ etpub/src/game/g_active.c	2005-03-15 09:42:37.000000000 -0600
@@ -17,7 +17,8 @@
 	vec3_t	angles;
 
 	client = player->client;
-	if ( client->ps.pm_type == PM_DEAD ) {
+	if ( client->ps.pm_type == PM_DEAD &&
+		!(client->ps.eFlags & EF_PLAYDEAD)) {
 		return;
 	}
 
@@ -374,7 +375,9 @@
 	ent->client->touchingTOI = NULL;
 
 	// dead clients don't activate triggers!
-	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {
+	// tjw: unless they're only playing.
+	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 &&
+		!(ent->client->ps.eFlags & EF_PLAYDEAD)) {
 		return;
 	}
 
@@ -563,7 +566,9 @@
 												g_spectatorInactivity.integer);
 
 	} else if ( !client->pers.localClient ) {
-		if ( level.time > client->inactivityTime && client->inactivityWarning) {
+		if(level.time > client->inactivityTime && 
+			client->inactivityWarning &&
+			!G_shrubbot_permission(&g_entities[client-level.clients], SBF_IMMUNITY)) {
 			client->inactivityWarning = qfalse;
 			client->inactivityTime = level.time + 60 * 1000;
 			trap_DropClient(client - level.clients, "Dropped due to inactivity", 0 );
@@ -599,7 +604,8 @@
 		client->timeResidual -= 1000;
 
 		// regenerate
-		if( client->sess.playerType == PC_MEDIC ) {
+		// tjw: dead players can't regenerate
+		if( client->sess.playerType == PC_MEDIC && !(client->ps.eFlags & EF_DEAD) ) {
 			if( ent->health < client->ps.stats[STAT_MAX_HEALTH]) {
 				ent->health += 3;
 				if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] * 1.1){
@@ -618,6 +624,10 @@
 			}
 		}
 	}
+	
+	// notify client that they are playing dead
+	if(client->ps.eFlags & EF_PLAYDEAD && ent->health > 0)
+		CP("cp \"Playing Dead\" 1");
 }
 
 /*
@@ -655,9 +665,13 @@
 	gclient_t	*client;
 	int			damage;
 	vec3_t		dir;
+	gentity_t	*victim;
+	int		kb_time = 0;
 
 	client = ent->client;
 
+	victim = &level.gentities[ent->s.groundEntityNum];
+
 	if ( oldEventSequence < client->ps.eventSequence - MAX_EVENTS ) {
 		oldEventSequence = client->ps.eventSequence - MAX_EVENTS;
 	}
@@ -673,7 +687,7 @@
 		//case EV_FALL_DMG_30:
 		case EV_FALL_DMG_50:
 		//case EV_FALL_DMG_75:
-			
+
 			if ( ent->s.eType != ET_PLAYER ) {
 				break;		// not in the player model
 			}
@@ -684,34 +698,51 @@
 			else if (event == EV_FALL_DMG_50)
 			{
 				damage = 50;
-				ent->client->ps.pm_time = 1000;
-				ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
-				VectorClear (ent->client->ps.velocity);
+				kb_time = 1000;
 			}
 			else if (event == EV_FALL_DMG_25)
 			{
 				damage = 25;
-				ent->client->ps.pm_time = 250;
-				ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
-				VectorClear (ent->client->ps.velocity);
+				kb_time = 500;
 			}
 			else if (event == EV_FALL_DMG_15)
 			{
 				damage = 15;
-				ent->client->ps.pm_time = 1000;
-				ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
-				VectorClear (ent->client->ps.velocity);
+				kb_time = 250;
 			}
 			else if (event == EV_FALL_DMG_10)
 			{
 				damage = 10;
-				ent->client->ps.pm_time = 1000;
-				ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
-				VectorClear (ent->client->ps.velocity);
+				kb_time = 250;
 			}
 			else
 				damage = 5; // never used
+
+			VectorClear (ent->client->ps.velocity);
+
 			VectorSet (dir, 0, 0, 1);
+			
+			if(kb_time) {
+				ent->client->ps.pm_time = kb_time;
+				ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			}
+
+			if(victim->client && 
+				victim->s.eType == ET_PLAYER && 
+				g_goomba.integer) {
+
+				if(kb_time) {
+					victim->client->ps.pm_time = kb_time;
+					victim->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+				}
+				victim->pain_debounce_time = level.time + 200;	// no normal pain sound
+				G_Damage (victim, ent, ent, NULL, NULL, (damage*g_goomba.integer*2), 0, MOD_CRUSH);
+				G_AddEvent(victim, EV_GENERAL_SOUND,
+					G_SoundIndex("sound/world/debris1.wav"));
+				// faller has a soft landing
+				damage *= 0.2f;
+			}
+			
 			ent->pain_debounce_time = level.time + 200;	// no normal pain sound
 			G_Damage (ent, NULL, NULL, NULL, NULL, damage, 0, MOD_FALLING);
 			break;
@@ -967,6 +998,11 @@
 		SpectatorThink( ent, ucmd );
 		return;
 	}
+	// bani's flamethrower exploit fix
+	if( client->flametime && level.time > client->flametime ) {
+		client->flametime = 0;
+		ent->r.svFlags &= ~SVF_BROADCAST;
+	}
 
 	if((client->ps.eFlags & EF_VIEWING_CAMERA) || level.match_pause != PAUSE_NONE
 #ifdef SAVEGAME_SUPPORT
@@ -993,11 +1029,19 @@
 			VectorClear(client->ps.velocity);
 			client->ps.pm_type = PM_FREEZE;
 		}
-	} else if ( client->noclip ) {
+	} 
+	else if ( client->noclip ) {
 		client->ps.pm_type = PM_NOCLIP;
-	} else if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
+	} 
+	else if(client->ps.pm_type == PM_PLAYDEAD) {
+		// no need to change it since it will
+		// be adjusted by PM_CheckPlayDead regardless
+	}
+	else if(client->ps.stats[STAT_HEALTH] <= 0 || 
+		client->ps.eFlags & EF_PLAYDEAD) {
 		client->ps.pm_type = PM_DEAD;
-	} else {
+	} 
+	else {
 		client->ps.pm_type = PM_NORMAL;
 	}
 
@@ -1192,7 +1236,10 @@
 	VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
 
 	// store the client's current position for antilag traces
-	G_StoreClientPosition( ent );
+	// Neil Toronto says this should be in ClientEndFrame NOT here.
+	// This should track server frames NOT client ones since clients
+	// interpolate what the server says
+	// G_StoreClientPosition( ent );
 
 	// touch other objects
 	ClientImpacts( ent, &pm );
@@ -1231,7 +1278,8 @@
 	}
 
 	// check for respawning
-	if( client->ps.stats[STAT_HEALTH] <= 0 ) {
+	if( client->ps.stats[STAT_HEALTH] <= 0 && 
+		!(client->ps.eFlags & EF_PLAYDEAD)) {
 
 		// DHM - Nerve
 		WolfFindMedic( ent );
@@ -1353,6 +1401,13 @@
 		gclient_t *cl;
 		qboolean do_respawn = qfalse; // JPW NERVE
 
+		/*
+		G_Printf("(dwRedReinfOffset %d + timeCurrent %d - startTime %d) lastReinforceTime %d\n",
+			level.dwRedReinfOffset,
+			level.timeCurrent,
+			level.startTime,
+			ent->client->pers.lastReinforceTime);
+		*/
 		// Players can respawn quickly in warmup
 		if(g_gamestate.integer != GS_PLAYING && ent->client->respawnTime <= level.timeCurrent &&
 		  ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
@@ -1367,6 +1422,11 @@
 			do_respawn = (testtime < ent->client->pers.lastReinforceTime);
 			ent->client->pers.lastReinforceTime = testtime;
 		}
+		/*
+		G_Printf("testtime %d lastReinforceTime %d\n\n",
+			testtime,
+			ent->client->pers.lastReinforceTime);
+		*/
 
 		if( g_gametype.integer != GT_WOLF_LMS ) {
 			if ( ( g_maxlives.integer > 0 || g_alliedmaxlives.integer > 0 || g_axismaxlives.integer > 0 )
@@ -1698,8 +1758,10 @@
 		ent->s.eFlags &= ~EF_CONNECTION;
 	}
 
-	ent->client->ps.stats[STAT_HEALTH] = ent->health;	// FIXME: get rid of ent->health...
-														// Gordon: WHY? other ents use it.
+	// don't tell the clients about this player's health
+	// when using playdead.  It's a secret.
+	if(!(ent->s.eFlags & EF_PLAYDEAD))
+		ent->client->ps.stats[STAT_HEALTH] = ent->health; 
 
 	G_SetClientSound (ent);
 
@@ -1724,7 +1786,11 @@
 		ent->r.contents = CONTENTS_CORPSE;
 	}
 
-	if ( ent->health > 0 && ent->r.contents == CONTENTS_CORPSE && !(ent->s.eFlags & EF_MOUNTEDTANK)) {
+	if ( ent->health > 0 && 
+		ent->r.contents == CONTENTS_CORPSE && 
+		!(ent->s.eFlags & EF_MOUNTEDTANK) &&
+		!(ent->s.eFlags & EF_PLAYDEAD)
+		) {
 		WolfReviveBbox( ent );
 	}
 
@@ -1735,4 +1801,8 @@
 
 	// run entity scripting
 	G_Script_ScriptRun( ent );
+
+	// josh: moved over from ClientThink see the note there
+	// We want this to track the server's viewpoint
+	G_StoreClientPosition( ent );
 }
diff -urN --exclude=.svn et.orig/src/game/g_antilag.c etpub/src/game/g_antilag.c
--- et.orig/src/game/g_antilag.c	2003-09-02 15:50:26.000000000 -0500
+++ etpub/src/game/g_antilag.c	2005-03-17 19:46:37.000000000 -0600
@@ -16,26 +16,43 @@
 	top = ent->client->topMarker;
 
 	// new frame, mark the old marker's time as the end of the last frame
-	if( ent->client->clientMarkers[top].time < level.time) {
-		ent->client->clientMarkers[top].time = level.previousTime;
-		top = ent->client->topMarker = ent->client->topMarker == MAX_CLIENT_MARKERS - 1 ? 0 : ent->client->topMarker + 1;
-	}
-
-	currentTime = level.previousTime + trap_Milliseconds() - level.frameTime;
+	// josh: Take this out now that Store is moved
+	//if( ent->client->clientMarkers[top].time < level.time) {
+	//	ent->client->clientMarkers[top].time = level.previousTime;
+	//	top = ent->client->topMarker = ent->client->topMarker == MAX_CLIENT_MARKERS - 1 ? 0 : ent->client->topMarker + 1;
+	//}
 
-	if(currentTime > level.time) {
-		// owwie, we just went into the next frame... let's push them back
-		currentTime = level.time;
-	}
+	// this is the correct time to use
+	currentTime = level.time;
 
 	VectorCopy( ent->r.mins,						ent->client->clientMarkers[top].mins );
 	VectorCopy( ent->r.maxs,						ent->client->clientMarkers[top].maxs );
-	VectorCopy( ent->r.currentOrigin,				ent->client->clientMarkers[top].origin );
+	// change to trbase instead of origin, correct for client (use s!!)
+	VectorCopy( ent->s.pos.trBase,				ent->client->clientMarkers[top].origin );
 	ent->client->clientMarkers[top].servertime =	level.time;
 	ent->client->clientMarkers[top].time =			currentTime;
+	ent->client->clientMarkers[top].eFlags = ent->s.eFlags;
+
+	// Check eFlags and alter the hit boxes accordingly
+	if(((ent->s.eFlags & EF_DEAD) ||
+		(ent->s.eFlags & EF_PLAYDEAD) ||
+		(ent->s.eFlags & EF_PRONE)) &&
+		ent->client->clientMarkers[top].maxs[2] != 4) {
+		ent->client->clientMarkers[top].maxs[2] = 4;
+	}
+	else if((ent->s.eFlags & EF_CROUCHING) &&
+		ent->client->clientMarkers[top].maxs[2] != 18) {
+		ent->client->clientMarkers[top].maxs[2] = 18;
+	}
+	// josh: tjw, is this supposed to be ! ?
+	else if(!(ent->s.eFlags & EF_MOUNTEDTANK) &&
+		ent->client->clientMarkers[top].maxs[2] != 36) {
+		ent->client->clientMarkers[top].maxs[2] = 36;
+	}
+
 }
 
-static void G_AdjustSingleClientPosition( gentity_t* ent, int time ) {
+void G_AdjustSingleClientPosition( gentity_t* ent, int time ) {
 	int i, j;
 
 	if( time > level.time) {
@@ -56,9 +73,16 @@
 		return;
 	}
 
-	VectorCopy(ent->r.currentOrigin,	ent->client->backupMarker.origin);
-	VectorCopy(ent->r.mins,				ent->client->backupMarker.mins);
-	VectorCopy(ent->r.maxs,				ent->client->backupMarker.maxs);
+	// josh: from unlagged make sure it doesn't get backed-up twice
+	if ( ent->client->backupMarker.time != level.time ) {
+		VectorCopy(ent->r.currentOrigin,	ent->client->backupMarker.origin);
+		VectorCopy(ent->r.mins,				ent->client->backupMarker.mins);
+		VectorCopy(ent->r.maxs,				ent->client->backupMarker.maxs);
+		// josh: backup the flags too
+		ent->client->backupMarker.eFlags = ent->client->ps.eFlags;
+		// josh: This was missing, but needed or else no readjustment
+		ent->client->backupMarker.time = level.time;
+	}
 
 	if(i != ent->client->topMarker) {
 		float frac = ((float)(ent->client->clientMarkers[j].time - time)) / (ent->client->clientMarkers[j].time - ent->client->clientMarkers[i].time);
@@ -66,16 +90,24 @@
 		LerpPosition(ent->client->clientMarkers[j].origin,		ent->client->clientMarkers[i].origin,	frac,	ent->r.currentOrigin);
 		LerpPosition(ent->client->clientMarkers[j].mins,		ent->client->clientMarkers[i].mins,		frac,	ent->r.mins);
 		LerpPosition(ent->client->clientMarkers[j].maxs,		ent->client->clientMarkers[i].maxs,		frac,	ent->r.maxs);
+		// josh: Set the eflags to the closest one in time since you can't
+		//       lerp flags.
+		if (ent->client->clientMarkers[j].time - time < time - ent->client->clientMarkers[i].time) {
+			ent->client->ps.eFlags = ent->client->clientMarkers[j].eFlags;
+		} else {
+			ent->client->ps.eFlags = ent->client->clientMarkers[i].eFlags;
+		}
 	} else {
 		VectorCopy( ent->client->clientMarkers[j].origin,		ent->r.currentOrigin );
 		VectorCopy( ent->client->clientMarkers[j].mins,			ent->r.mins );
 		VectorCopy( ent->client->clientMarkers[j].maxs,			ent->r.maxs );
+		ent->client->ps.eFlags = ent->client->clientMarkers[j].eFlags;
 	}
 
 	trap_LinkEntity( ent );
 }
 
-static void G_ReAdjustSingleClientPosition( gentity_t* ent ) {
+void G_ReAdjustSingleClientPosition( gentity_t* ent ) {
 	if(!ent || !ent->client) {
 		return;
 	}
@@ -84,8 +116,8 @@
 		VectorCopy( ent->client->backupMarker.origin,		ent->r.currentOrigin );
 		VectorCopy( ent->client->backupMarker.mins,			ent->r.mins );
 		VectorCopy( ent->client->backupMarker.maxs,			ent->r.maxs );
-					ent->client->backupMarker.servertime =	0;
-
+		ent->client->ps.eFlags = ent->client->backupMarker.eFlags;
+		ent->client->backupMarker.servertime =	0;
 		trap_LinkEntity( ent );
 	}
 }
@@ -151,9 +183,9 @@
  				(list->client->sess.sessionTeam == TEAM_AXIS || list->client->sess.sessionTeam == TEAM_ALLIES) && 
  				(list != ent) &&
  				list->r.linked &&
- 				(list->health > 0) &&
  				!(list->client->ps.pm_flags & PMF_LIMBO) &&
-				(list->client->ps.pm_type == PM_NORMAL)
+				((list->client->ps.pm_type == PM_NORMAL) ||
+				 (list->client->ps.pm_type == PM_DEAD))
  		) {
 			list->client->tempHead = G_BuildHead( list );
 			list->client->tempLeg = G_BuildLeg( list );
@@ -230,7 +262,8 @@
 
 	G_AdjustClientPositions( ent, 0, qfalse );
 
-	if( results->entityNum >= 0 && results->entityNum < MAX_CLIENTS && (other = &g_entities[results->entityNum])->inuse ) {
+	// g_antilag 2: do the extra occlusion test. Don't ever use this: evil
+	if( g_antilag.integer == 2 && results->entityNum >= 0 && results->entityNum < MAX_CLIENTS && (other = &g_entities[results->entityNum])->inuse ) {
 		G_AttachBodyParts( ent ) ;
 
 		trap_Trace( &tr, start, mins, maxs, other->client->ps.origin, passEntityNum, contentmask );
diff -urN --exclude=.svn et.orig/src/game/g_client.c etpub/src/game/g_client.c
--- et.orig/src/game/g_client.c	2003-08-28 15:43:22.000000000 -0500
+++ etpub/src/game/g_client.c	2005-03-18 15:40:26.000000000 -0600
@@ -297,11 +297,13 @@
 */ 
 void BodySink2( gentity_t *ent ) {
 	ent->physicsObject = qfalse;
-    ent->nextthink = level.time + BODY_TIME(BODY_TEAM(ent))+1500;
-    ent->think = BodyUnlink;
-    ent->s.pos.trType = TR_LINEAR;
-    ent->s.pos.trTime = level.time;
-    VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+	// tjw: BODY_TIME is how long they last all together, not just sink anim
+	//ent->nextthink = level.time + BODY_TIME(BODY_TEAM(ent))+1500;
+	ent->nextthink = level.time + 4000;
+	ent->think = BodyUnlink;
+	ent->s.pos.trType = TR_LINEAR;
+	ent->s.pos.trTime = level.time;
+	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
 	VectorSet( ent->s.pos.trDelta, 0, 0, -8 );
 }
 
@@ -418,10 +420,11 @@
 	body->r.contents = CONTENTS_CORPSE;
 	body->r.ownerNum = ent->r.ownerNum;
 
-	BODY_TEAM(body) =		ent->client->sess.sessionTeam;
-	BODY_CLASS(body) =		ent->client->sess.playerType;
-	BODY_CHARACTER(body) =	ent->client->pers.characterIndex;
-	BODY_VALUE(body) =		0;
+	BODY_TEAM(body) = ent->client->sess.sessionTeam;
+	BODY_CLASS(body) = ent->client->sess.playerType;
+	BODY_CHARACTER(body) = ent->client->pers.characterIndex;
+	BODY_VALUE(body) = 0;
+	BODY_WEAPON(body) = ent->client->sess.playerWeapon;
 
 	body->s.time2 =			0;
 
@@ -478,6 +481,99 @@
 	VectorCopy( ent->s.angles, ent->client->ps.viewangles);
 }
 
+
+void G_DropLimboHealth(gentity_t *ent)
+{
+	vec3_t launchvel, launchspot;
+	int packs = 0;
+	int i;
+	int cwt;
+
+	if(g_dropHealth.integer == 0) return;
+	if(!ent->client) return;
+	if(ent->client->sess.playerType != PC_MEDIC) 
+		return;
+
+	packs = g_dropHealth.integer;
+	if(g_dropHealth.integer == -1) {
+		packs = 5; // max packs
+		cwt = ent->client->ps.classWeaponTime;
+		ent->client->ps.classWeaponTime +=
+			(level.time
+				- ent->client->deathTime
+				+ 10000);
+	}
+	for(i=0; i<packs; i++) {
+		if(g_dropHealth.integer == -1 &&
+			ent->client->ps.classWeaponTime >= level.time) {
+
+			break;
+		}
+		launchvel[0] = crandom();
+		launchvel[1] = crandom();
+		launchvel[2] = 0;
+		VectorScale(launchvel, 100, launchvel);
+		launchvel[2] = (100 + (g_tossDistance.integer * 10));
+		VectorCopy(ent->r.currentOrigin, launchspot);
+		
+		Weapon_Medic_Ext(ent,
+			launchspot,
+			launchspot,
+			launchvel);
+	}
+	ent->client->ps.classWeaponTime = cwt;
+}
+
+void G_DropLimboAmmo(gentity_t *ent)
+{
+	vec3_t launchvel, launchspot;
+	int packs = 0;
+	int i;
+	int cwt;
+
+	if(g_dropAmmo.integer == 0) return;
+	if(!ent->client) return;
+	if(ent->client->sess.playerType != PC_FIELDOPS) 
+		return;
+
+	packs = g_dropAmmo.integer;
+	if(g_dropAmmo.integer == -1) {
+		packs = 5; // max packs
+		cwt = ent->client->ps.classWeaponTime;
+		// adjust the charge timer so that the
+		// fops only drops as much ammo as he
+		// could have before he died.
+		// don't ask me where the 10000 comes
+		// from, it just makes this more
+		// accurate.
+		ent->client->ps.classWeaponTime +=
+			(level.time 
+				- ent->client->deathTime
+				+ 10000);
+	}
+	for(i=0; i<packs; i++) {
+		if(g_dropAmmo.integer == -1 &&
+			ent->client->ps.classWeaponTime >= level.time) {
+
+			break;
+		}
+		launchvel[0] = crandom();
+		launchvel[1] = crandom();
+		launchvel[2] = 0;
+
+		VectorScale(launchvel, 100, launchvel);
+		launchvel[2] = (100 + (g_tossDistance.integer * 10));
+		VectorCopy(ent->r.currentOrigin, launchspot);
+		
+		Weapon_MagicAmmo_Ext(ent,
+			launchspot,
+			launchspot,
+			launchvel);
+	}
+	ent->client->ps.classWeaponTime = cwt;
+}
+
+
 /* JPW NERVE
 ================
 limbo
@@ -513,6 +609,8 @@
 
 		
 		if( makeCorpse ) {
+			G_DropLimboHealth(ent);
+			G_DropLimboAmmo(ent);
 			CopyToBodyQue (ent); // make a nice looking corpse
 		} else {
 			trap_UnlinkEntity (ent);
@@ -648,7 +746,7 @@
 
 	G_DPrintf( "Respawning %s, %i lives left\n", ent->client->pers.netname, ent->client->ps.persistant[PERS_RESPAWNS_LEFT]);
 
-	ClientSpawn(ent, qfalse);
+	ClientSpawn(ent, qfalse, qfalse, qtrue);
 
 	// DHM - Nerve :: Add back if we decide to have a spawn effect
 	// add a teleportation effect
@@ -788,6 +886,441 @@
 
 void BotSetPOW(int entityNum, qboolean isPOW);
 
+
+
+/*
+ G_AddClassSpecificTools  //tjw
+ This stuff was stripped out of SetWolfSpawnWeapons()  so it can
+ be used for class stealing.  It needed cleaning up badly anyway.
+ It still does.
+ */
+void G_AddClassSpecificTools(gclient_t *client) 
+{
+	int	pc = client->sess.playerType;
+	qboolean add_binocs = qfalse;
+
+	if(client->sess.skill[SK_BATTLE_SENSE] >= 1)
+		add_binocs = qtrue;
+
+	switch(client->sess.playerType) {
+		case PC_ENGINEER:
+			AddWeaponToPlayer( client, WP_DYNAMITE, 0, 1, qfalse );
+			AddWeaponToPlayer( client, WP_PLIERS, 0, 1, qfalse );
+			AddWeaponToPlayer( client, 
+				WP_LANDMINE,
+				GetAmmoTableData(WP_LANDMINE)->defaultStartingAmmo,
+				GetAmmoTableData(WP_LANDMINE)->defaultStartingClip,
+				qfalse );
+			break;
+		case PC_COVERTOPS:
+			add_binocs = qtrue;
+			AddWeaponToPlayer(client,
+				WP_SMOKE_BOMB,
+				GetAmmoTableData(WP_SMOKE_BOMB)->defaultStartingAmmo,
+				GetAmmoTableData(WP_SMOKE_BOMB)->defaultStartingClip,
+				qfalse);
+			// See if we already have a satchel charge placed 
+			// this needs to be here for class stealing
+			if( G_FindSatchel( &g_entities[client->ps.clientNum] ) ) {
+				AddWeaponToPlayer( client, WP_SATCHEL, 0, 0, qfalse );
+				AddWeaponToPlayer( client, WP_SATCHEL_DET, 0, 1, qfalse );
+			} else {
+				AddWeaponToPlayer( client, WP_SATCHEL, 0, 1, qfalse );
+				AddWeaponToPlayer( client, WP_SATCHEL_DET, 0, 0, qfalse );
+			}
+			break;
+		case PC_FIELDOPS:
+			add_binocs = qtrue;
+			AddWeaponToPlayer(client, WP_AMMO, 0, 1, qfalse);
+			AddWeaponToPlayer( client, 
+				WP_SMOKE_MARKER,
+				GetAmmoTableData(WP_SMOKE_MARKER)->defaultStartingAmmo,
+				GetAmmoTableData(WP_SMOKE_MARKER)->defaultStartingClip,
+				qfalse);
+			break;
+		case PC_MEDIC:
+			AddWeaponToPlayer(client,
+				WP_MEDIC_SYRINGE,
+				GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingAmmo,
+				GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingClip,
+				qfalse);
+			if( client->sess.skill[SK_FIRST_AID] >= 4 )
+				AddWeaponToPlayer(client,
+					WP_MEDIC_ADRENALINE,
+					GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingAmmo,
+					GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingClip,
+					qfalse);
+
+			AddWeaponToPlayer(client,
+				WP_MEDKIT,
+				GetAmmoTableData(WP_MEDKIT)->defaultStartingAmmo,
+				GetAmmoTableData(WP_MEDKIT)->defaultStartingClip,
+				qfalse);
+			break;
+		case PC_SOLDIER:
+			break;
+	}
+	if(add_binocs) {
+		if(AddWeaponToPlayer(client, WP_BINOCULARS, 1, 0, qfalse)) {
+			client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
+		}
+	}
+	//// Josh: adren in different classes when level 4
+	if( (client->sess.playerType != PC_MEDIC
+		  && (g_skills.integer & SKILLS_ADREN))
+		  && client->sess.skill[SK_FIRST_AID] >= 4 )
+		AddWeaponToPlayer(client,
+			WP_MEDIC_ADRENALINE,
+			GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingAmmo,
+			GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingClip,
+			qfalse);
+
+}
+
+qboolean _SetSoldierSpawnWeapons(gclient_t *client) 
+{
+	weapon_t w;
+	weapon_t w2, w3 = 0;
+	weapon_t ws = 0;
+
+	w = client->sess.latchPlayerWeapon;
+	if(client->sess.sessionTeam == TEAM_AXIS) {
+		switch(w) {
+			case WP_MP40:
+			case WP_PANZERFAUST:
+			case WP_MORTAR:
+			case WP_FLAMETHROWER:
+			case WP_MOBILE_MG42:
+				break;
+			default:
+				w = WP_MP40;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_LAUNCHER, 0, 4, qfalse);
+		w2 = WP_LUGER;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_LUGER;
+		}
+		if( client->sess.skill[SK_HEAVY_WEAPONS] >= 4) {
+			w3 = WP_MP40;
+			if(!(g_weapons.integer & WPF_L4HW_KEEPS_PISTOL)) 
+				w2 = 0;
+		}
+	}
+	else if(client->sess.sessionTeam == TEAM_ALLIES) {
+		switch(w) {
+			case WP_THOMPSON:
+			case WP_PANZERFAUST:
+			case WP_MORTAR:
+			case WP_FLAMETHROWER:
+			case WP_MOBILE_MG42:
+				break;
+			default:
+				w = WP_THOMPSON;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_PINEAPPLE, 0, 4, qfalse);
+		w2 = WP_COLT;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_COLT;
+		}
+		if( client->sess.skill[SK_HEAVY_WEAPONS] >= 4) {
+			w3 = WP_THOMPSON;
+			if(!(g_weapons.integer & WPF_L4HW_KEEPS_PISTOL)) 
+				w2 = 0;
+		}
+	}
+	else {
+		return qfalse;
+	}
+
+	AddWeaponToPlayer(client,
+		w,
+		GetAmmoTableData(w)->defaultStartingAmmo,
+		GetAmmoTableData(w)->defaultStartingClip,
+		qtrue);
+	
+	if(w == WP_MOBILE_MG42) {
+		ws = WP_MOBILE_MG42_SET;
+	}
+	else if(w == WP_MORTAR) {
+		ws = WP_MORTAR_SET;
+	}
+
+	if(ws) {
+		AddWeaponToPlayer(client,
+			ws,
+			GetAmmoTableData(ws)->defaultStartingAmmo,
+			GetAmmoTableData(ws)->defaultStartingClip,
+			qfalse);
+	}
+	if(w2 == WP_AKIMBO_LUGER || w2 == WP_AKIMBO_COLT) {
+		client->ps.ammoclip[
+			BG_FindClipForWeapon(BG_AkimboSidearm(w2))] = 
+			GetAmmoTableData(w2)->defaultStartingClip;
+	}
+	AddWeaponToPlayer(client,
+		w2,
+		GetAmmoTableData(w2)->defaultStartingAmmo,
+		GetAmmoTableData(w2)->defaultStartingClip,
+		qfalse);
+	if(w3) {
+		AddWeaponToPlayer(client,
+			w3,
+			2*GetAmmoTableData(w3)->defaultStartingAmmo,
+			GetAmmoTableData(w3)->defaultStartingClip,
+			qfalse);
+	}
+	return qtrue;
+}
+
+qboolean _SetMedicSpawnWeapons(gclient_t *client) 
+{
+	weapon_t w;
+	weapon_t w2;
+
+	if(client->sess.sessionTeam == TEAM_AXIS) {
+		w = WP_MP40;
+		AddWeaponToPlayer(client, WP_GRENADE_LAUNCHER, 0, 1, qfalse);
+		w2 = WP_LUGER;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_LUGER;
+		}
+	}
+	else if(client->sess.sessionTeam == TEAM_ALLIES) {
+		w = WP_THOMPSON;
+		AddWeaponToPlayer(client, WP_GRENADE_PINEAPPLE, 0, 1, qfalse);
+		w2 = WP_COLT;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_COLT;
+		}
+	}
+	else {
+		return qfalse;
+	}
+
+	AddWeaponToPlayer(client,
+		w,
+		0,
+		GetAmmoTableData(w)->defaultStartingClip,
+		qtrue);
+
+	if(w2 == WP_AKIMBO_LUGER || w2 == WP_AKIMBO_COLT) {
+		client->ps.ammoclip[
+			BG_FindClipForWeapon(BG_AkimboSidearm(w2))] = 
+			GetAmmoTableData(w2)->defaultStartingClip;
+	}
+	AddWeaponToPlayer(client,
+		w2,
+		GetAmmoTableData(w2)->defaultStartingAmmo,
+		GetAmmoTableData(w2)->defaultStartingClip,
+		qfalse);
+	return qtrue;
+}
+
+qboolean _SetEngineerSpawnWeapons(gclient_t *client) 
+{
+	weapon_t w;
+	weapon_t w2;
+
+	w = client->sess.latchPlayerWeapon;
+	if(client->sess.sessionTeam == TEAM_AXIS) {
+		switch(w) {
+			case WP_KAR98:
+			case WP_MP40:
+				break;
+			default:
+				w = WP_MP40;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_LAUNCHER, 0, 4, qfalse);
+		w2 = WP_LUGER;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_LUGER;
+		}
+	}
+	else if(client->sess.sessionTeam == TEAM_ALLIES) {
+		switch(w) {
+			case WP_CARBINE:
+			case WP_THOMPSON:
+				break;
+			default:
+				w = WP_THOMPSON;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_PINEAPPLE, 0, 4, qfalse);
+		w2 = WP_COLT;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_COLT;
+		}
+	}
+	else {
+		return qfalse;
+	}
+
+	AddWeaponToPlayer(client,
+		w,
+		GetAmmoTableData(w)->defaultStartingAmmo,
+		GetAmmoTableData(w)->defaultStartingClip,
+		qtrue);
+
+	if(w == WP_KAR98) {
+		AddWeaponToPlayer(client,
+			WP_GPG40,
+			GetAmmoTableData(WP_GPG40)->defaultStartingAmmo,
+			GetAmmoTableData(WP_GPG40)->defaultStartingClip,
+			qfalse);
+	}
+	else if(w == WP_CARBINE) {
+		AddWeaponToPlayer(client,
+			WP_M7,
+			GetAmmoTableData(WP_M7)->defaultStartingAmmo,
+			GetAmmoTableData(WP_M7)->defaultStartingClip,
+			qfalse);
+	}
+	if(w2 == WP_AKIMBO_LUGER || w2 == WP_AKIMBO_COLT) {
+		client->ps.ammoclip[
+			BG_FindClipForWeapon(BG_AkimboSidearm(w2))] = 
+			GetAmmoTableData(w2)->defaultStartingClip;
+	}
+	AddWeaponToPlayer(client,
+		w2,
+		GetAmmoTableData(w2)->defaultStartingAmmo,
+		GetAmmoTableData(w2)->defaultStartingClip,
+		qfalse);
+	return qtrue;
+}
+
+qboolean _SetFieldOpSpawnWeapons(gclient_t *client) 
+{
+	weapon_t w;
+	weapon_t w2;
+
+	if(client->sess.sessionTeam == TEAM_AXIS) {
+		w = WP_MP40;
+		AddWeaponToPlayer(client, WP_GRENADE_LAUNCHER, 0, 1, qfalse);
+		w2 = WP_LUGER;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_LUGER;
+		}
+	}
+	else if(client->sess.sessionTeam == TEAM_ALLIES) {
+		w = WP_THOMPSON;
+		AddWeaponToPlayer(client, WP_GRENADE_PINEAPPLE, 0, 1, qfalse);
+		w2 = WP_COLT;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_COLT;
+		}
+	}
+	else {
+		return qfalse;
+	}
+
+	AddWeaponToPlayer(client,
+		w,
+		GetAmmoTableData(w)->defaultStartingAmmo,
+		GetAmmoTableData(w)->defaultStartingClip,
+		qtrue);
+
+	if(w2 == WP_AKIMBO_LUGER || w2 == WP_AKIMBO_COLT) {
+		client->ps.ammoclip[
+			BG_FindClipForWeapon(BG_AkimboSidearm(w2))] = 
+			GetAmmoTableData(w2)->defaultStartingClip;
+	}
+	AddWeaponToPlayer(client,
+		w2,
+		GetAmmoTableData(w2)->defaultStartingAmmo,
+		GetAmmoTableData(w2)->defaultStartingClip,
+		qfalse);
+	return qtrue;
+
+}
+
+qboolean _SetCovertSpawnWeapons(gclient_t *client) 
+{
+	weapon_t w;
+	weapon_t w2, w3;
+	weapon_t ws = 0;
+
+	w = client->sess.latchPlayerWeapon;
+	if(client->sess.sessionTeam== TEAM_AXIS) {
+		switch(w) {
+			case WP_K43:
+			case WP_FG42:
+			case WP_STEN:
+				break;
+			default:
+				w = WP_STEN;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_LAUNCHER, 0, 2, qfalse);
+		w2 = WP_SILENCER;
+		w3 = WP_LUGER;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_SILENCEDLUGER;
+			w3 = 0;
+		}
+	}
+	else if(client->sess.sessionTeam == TEAM_ALLIES) {
+		switch(w) {
+			case WP_GARAND:
+			case WP_FG42:
+			case WP_STEN:
+				break;
+			default:
+				w = WP_STEN;
+		}
+		AddWeaponToPlayer(client, WP_GRENADE_PINEAPPLE, 0, 2, qfalse);
+		w2 = WP_SILENCED_COLT;
+		w3 = WP_COLT;
+		if(client->sess.skill[SK_LIGHT_WEAPONS] >= 4) {
+			w2 = WP_AKIMBO_SILENCEDCOLT;
+			w3 = 0;
+		}
+	}
+	else {
+		return qfalse;
+	}
+
+	AddWeaponToPlayer(client,
+		w,
+		GetAmmoTableData(w)->defaultStartingAmmo,
+		GetAmmoTableData(w)->defaultStartingClip,
+		qtrue);
+	
+	if(w == WP_K43) {
+		ws = WP_K43_SCOPE;
+	}
+	else if(w == WP_GARAND) {
+		ws = WP_GARAND_SCOPE;
+	}
+	else if(w == WP_FG42) {
+		ws = WP_FG42SCOPE;
+	}
+
+	if(ws) {
+		AddWeaponToPlayer(client,
+			ws,
+			GetAmmoTableData(ws)->defaultStartingAmmo,
+			GetAmmoTableData(ws)->defaultStartingClip,
+			qfalse);
+	}
+	if(w2 == WP_AKIMBO_SILENCEDLUGER || w2 == WP_AKIMBO_SILENCEDCOLT) {
+		client->ps.ammoclip[
+		       	BG_FindClipForWeapon(BG_AkimboSidearm(w2))] = 
+			GetAmmoTableData(w2)->defaultStartingClip;
+	}
+	AddWeaponToPlayer(client,
+		w2,
+		GetAmmoTableData(w2)->defaultStartingAmmo,
+		GetAmmoTableData(w2)->defaultStartingClip,
+		qfalse);
+	if(w3) {
+		AddWeaponToPlayer(client,
+			w3,
+			GetAmmoTableData(w3)->defaultStartingAmmo,
+			GetAmmoTableData(w3)->defaultStartingClip,
+			qfalse);
+	}
+	client->pmext.silencedSideArm = 1;
+	return qtrue;
+}
+
 /*
 ===========
 SetWolfSpawnWeapons
@@ -795,11 +1328,18 @@
 */
 void SetWolfSpawnWeapons( gclient_t *client ) 
 {
-	int		pc = client->sess.playerType;
-	qboolean	isBot = (g_entities[client->ps.clientNum].r.svFlags & SVF_BOT) ? qtrue : qfalse;
-	qboolean	isPOW = (g_entities[client->ps.clientNum].r.svFlags & SVF_POW) ? qtrue : qfalse;
+	int pc;
+	qboolean isBot = qfalse;
+	qboolean isPOW = qfalse;
+
+       	pc = client->sess.playerType;
+	
+	if(g_entities[client->ps.clientNum].r.svFlags & SVF_BOT)
+		isBot = qtrue;
+	if(g_entities[client->ps.clientNum].r.svFlags & SVF_POW) 
+		isPOW = qtrue;
 
-	if ( client->sess.sessionTeam == TEAM_SPECTATOR )
+	if ( client->sess.sessionTeam == TEAM_SPECTATOR ) 
 		return;
 
 	// Reset special weapon time
@@ -808,13 +1348,15 @@
 	// Communicate it to cgame
 	client->ps.stats[STAT_PLAYER_CLASS] = pc;
 
-	// Abuse teamNum to store player class as well (can't see stats for all clients in cgame)
+	// Abuse teamNum to store player class as well (can't see stats 
+	// for all clients in cgame)
 	client->ps.teamNum = pc;
 
 	// JPW NERVE -- zero out all ammo counts
 	memset(client->ps.ammo, 0, MAX_WEAPONS * sizeof(int));
 
-	// All players start with a knife (not OR-ing so that it clears previous weapons)
+	// All players start with a knife (not OR-ing so that it clears 
+	// previous weapons)
 	client->ps.weapons[0] = 0;
 	client->ps.weapons[1] = 0;
 
@@ -832,279 +1374,37 @@
 
 	client->ps.weaponstate = WEAPON_READY;
 
-	// Engineer gets dynamite
-	if ( pc == PC_ENGINEER ) {
-		AddWeaponToPlayer( client, WP_DYNAMITE, 0, 1, qfalse );
-		AddWeaponToPlayer( client, WP_PLIERS, 0, 1, qfalse );
-
-		if( g_knifeonly.integer != 1 ) {
-			if( client->sess.skill[SK_BATTLE_SENSE] >= 1 ) {
-				if( AddWeaponToPlayer( client, WP_BINOCULARS, 1, 0, qfalse ) ) {
-					client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
-				}
-			}
-
-			if (client->sess.sessionTeam == TEAM_AXIS) {
-				switch( client->sess.playerWeapon ) {
-				case WP_KAR98:
-					if( AddWeaponToPlayer( client, WP_KAR98, GetAmmoTableData(WP_KAR98)->defaultStartingAmmo, GetAmmoTableData(WP_KAR98)->defaultStartingClip, qtrue ) ) {
-						AddWeaponToPlayer( client, WP_GPG40, GetAmmoTableData(WP_GPG40)->defaultStartingAmmo, GetAmmoTableData(WP_GPG40)->defaultStartingClip, qfalse );
-					}
-					break;
-				default:
-					AddWeaponToPlayer( client, WP_MP40, GetAmmoTableData(WP_MP40)->defaultStartingAmmo, GetAmmoTableData(WP_MP40)->defaultStartingClip, qtrue );
-					break;
-				}
-				AddWeaponToPlayer( client, WP_LANDMINE, GetAmmoTableData(WP_LANDMINE)->defaultStartingAmmo, GetAmmoTableData(WP_LANDMINE)->defaultStartingClip, qfalse );
-				AddWeaponToPlayer( client, WP_GRENADE_LAUNCHER, 0, 4, qfalse );
 
-			} else {
-				switch( client->sess.playerWeapon ) {
-				case WP_CARBINE:
-					if( AddWeaponToPlayer( client, WP_CARBINE, GetAmmoTableData(WP_CARBINE)->defaultStartingAmmo, GetAmmoTableData(WP_CARBINE)->defaultStartingClip, qtrue ) ) {
-						AddWeaponToPlayer( client, WP_M7, GetAmmoTableData(WP_M7)->defaultStartingAmmo, GetAmmoTableData(WP_M7)->defaultStartingClip, qfalse );
-					}
-					break;
-				default:
-					AddWeaponToPlayer( client, WP_THOMPSON, GetAmmoTableData(WP_THOMPSON)->defaultStartingAmmo, GetAmmoTableData(WP_THOMPSON)->defaultStartingClip, qtrue );
-					break;
-				}
-				AddWeaponToPlayer( client, WP_LANDMINE, GetAmmoTableData(WP_LANDMINE)->defaultStartingAmmo, GetAmmoTableData(WP_LANDMINE)->defaultStartingClip, qfalse );
-				AddWeaponToPlayer( client, WP_GRENADE_PINEAPPLE, 0, 4, qfalse );
-			}
-		}
+	// the only weapon other than knife is syringe apperantly no need
+	// for mile long conditionals
+	if( g_knifeonly.integer && pc == PC_MEDIC) {
+		AddWeaponToPlayer(client,
+			WP_MEDIC_SYRINGE,
+			GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingAmmo,
+			GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingClip,
+			qfalse);
+		return;
 	}
 
-	if ( g_knifeonly.integer != 1 ) {
-		// Field ops gets binoculars, ammo pack, artillery, and a grenade
-		if ( pc == PC_FIELDOPS ) {
-			AddWeaponToPlayer( client, WP_AMMO, 0, 1, qfalse );
-
-			if( AddWeaponToPlayer( client, WP_BINOCULARS, 1, 0, qfalse ) ) {
-				client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
-			}
-
-			AddWeaponToPlayer( client, WP_SMOKE_MARKER, GetAmmoTableData(WP_SMOKE_MARKER)->defaultStartingAmmo, GetAmmoTableData(WP_SMOKE_MARKER)->defaultStartingClip, qfalse );
-
-			if( client->sess.sessionTeam == TEAM_AXIS ) {
-				AddWeaponToPlayer( client, WP_MP40,  GetAmmoTableData(WP_MP40)->defaultStartingAmmo, GetAmmoTableData(WP_MP40)->defaultStartingClip, qtrue );
-				AddWeaponToPlayer( client, WP_GRENADE_LAUNCHER,  0, 1, qfalse );
-			} else {
-				AddWeaponToPlayer( client, WP_THOMPSON, GetAmmoTableData(WP_THOMPSON)->defaultStartingAmmo, GetAmmoTableData(WP_THOMPSON)->defaultStartingClip, qtrue );
-				AddWeaponToPlayer( client, WP_GRENADE_PINEAPPLE, 0, 1, qfalse );
-			}
-		} else if( pc == PC_MEDIC ) {
-			if( client->sess.skill[SK_BATTLE_SENSE] >= 1 ) {
-				if( AddWeaponToPlayer( client, WP_BINOCULARS, 1, 0, qfalse ) ) {
-					client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
-				}
-			}
-
-			AddWeaponToPlayer( client, WP_MEDIC_SYRINGE, GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingAmmo, GetAmmoTableData(WP_MEDIC_SYRINGE)->defaultStartingClip, qfalse );
-			if( client->sess.skill[SK_FIRST_AID] >= 4 )
-				AddWeaponToPlayer( client, WP_MEDIC_ADRENALINE, GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingAmmo, GetAmmoTableData(WP_MEDIC_ADRENALINE)->defaultStartingClip, qfalse );
-
-			AddWeaponToPlayer( client, WP_MEDKIT, GetAmmoTableData(WP_MEDKIT)->defaultStartingAmmo, GetAmmoTableData(WP_MEDKIT)->defaultStartingClip, qfalse );
-
-			if (client->sess.sessionTeam == TEAM_AXIS) {
-				AddWeaponToPlayer( client, WP_MP40, 0, GetAmmoTableData(WP_MP40)->defaultStartingClip, qtrue );
-				AddWeaponToPlayer( client, WP_GRENADE_LAUNCHER, 0, 1, qfalse );
-			} else {
-				AddWeaponToPlayer( client, WP_THOMPSON, 0, GetAmmoTableData(WP_THOMPSON)->defaultStartingClip, qtrue );
-				AddWeaponToPlayer( client, WP_GRENADE_PINEAPPLE, 0, 1, qfalse );
-			}
-		} else if ( pc == PC_SOLDIER ) {
-			if( client->sess.skill[SK_BATTLE_SENSE] >= 1 ) {
-				if( AddWeaponToPlayer( client, WP_BINOCULARS, 1, 0, qfalse ) ) {
-					client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
-				}
-			}
-
-			switch( client->sess.sessionTeam ) {
-				case TEAM_AXIS:
-					switch( client->sess.playerWeapon ) {
-					default:
-					case WP_MP40:
-						AddWeaponToPlayer( client, WP_MP40, 2*(GetAmmoTableData(WP_MP40)->defaultStartingAmmo), GetAmmoTableData(WP_MP40)->defaultStartingClip, qtrue );
-						break;
-					case WP_PANZERFAUST:
-						AddWeaponToPlayer( client, WP_PANZERFAUST, GetAmmoTableData(WP_PANZERFAUST)->defaultStartingAmmo, GetAmmoTableData(WP_PANZERFAUST)->defaultStartingClip, qtrue );
-						break;
-					case WP_FLAMETHROWER:
-						AddWeaponToPlayer( client, WP_FLAMETHROWER, GetAmmoTableData(WP_FLAMETHROWER)->defaultStartingAmmo, GetAmmoTableData(WP_FLAMETHROWER)->defaultStartingClip, qtrue );
-						break;
-					case WP_MOBILE_MG42:
-						if( AddWeaponToPlayer( client, WP_MOBILE_MG42, GetAmmoTableData(WP_MOBILE_MG42)->defaultStartingAmmo, GetAmmoTableData(WP_MOBILE_MG42)->defaultStartingClip, qtrue ) ) {
-							AddWeaponToPlayer( client, WP_MOBILE_MG42_SET, GetAmmoTableData(WP_MOBILE_MG42_SET)->defaultStartingAmmo, GetAmmoTableData(WP_MOBILE_MG42_SET)->defaultStartingClip, qfalse );
-						}
-						break;
-					case WP_MORTAR:
-						if( AddWeaponToPlayer( client, WP_MORTAR, GetAmmoTableData(WP_MORTAR)->defaultStartingAmmo, GetAmmoTableData(WP_MORTAR)->defaultStartingClip, qtrue ) ) {
-							AddWeaponToPlayer( client, WP_MORTAR_SET, GetAmmoTableData(WP_MORTAR_SET)->defaultStartingAmmo, GetAmmoTableData(WP_MORTAR_SET)->defaultStartingClip, qfalse );
-						}
-						break;
-					}
-					break;
-				case TEAM_ALLIES:
-					switch( client->sess.playerWeapon ) {
-					default:
-					case WP_THOMPSON:
-						AddWeaponToPlayer( client, WP_THOMPSON, 2*(GetAmmoTableData(WP_THOMPSON)->defaultStartingAmmo), GetAmmoTableData(WP_THOMPSON)->defaultStartingClip, qtrue );
-						break;
-					case WP_PANZERFAUST:
-						AddWeaponToPlayer( client, WP_PANZERFAUST, GetAmmoTableData(WP_PANZERFAUST)->defaultStartingAmmo, GetAmmoTableData(WP_PANZERFAUST)->defaultStartingClip, qtrue );
-						break;
-					case WP_FLAMETHROWER:
-						AddWeaponToPlayer( client, WP_FLAMETHROWER, GetAmmoTableData(WP_FLAMETHROWER)->defaultStartingAmmo, GetAmmoTableData(WP_FLAMETHROWER)->defaultStartingClip, qtrue );
-						break;
-					case WP_MOBILE_MG42:
-						if( AddWeaponToPlayer( client, WP_MOBILE_MG42, GetAmmoTableData(WP_MOBILE_MG42)->defaultStartingAmmo, GetAmmoTableData(WP_MOBILE_MG42)->defaultStartingClip, qtrue ) ) {
-							AddWeaponToPlayer( client, WP_MOBILE_MG42_SET, GetAmmoTableData(WP_MOBILE_MG42_SET)->defaultStartingAmmo, GetAmmoTableData(WP_MOBILE_MG42_SET)->defaultStartingClip, qfalse );
-						}
-						break;
-					case WP_MORTAR:
-						if( AddWeaponToPlayer( client, WP_MORTAR, GetAmmoTableData(WP_MORTAR)->defaultStartingAmmo, GetAmmoTableData(WP_MORTAR)->defaultStartingClip, qtrue ) ) {
-							AddWeaponToPlayer( client, WP_MORTAR_SET, GetAmmoTableData(WP_MORTAR_SET)->defaultStartingAmmo, GetAmmoTableData(WP_MORTAR_SET)->defaultStartingClip, qfalse );
-						}
-						break;
-					}
-					break;
-			}
-		} else if( pc == PC_COVERTOPS ) {
-			switch( client->sess.playerWeapon ) {				
-			case WP_K43:
-			case WP_GARAND:
-				if( client->sess.sessionTeam == TEAM_AXIS ) {
-					if( AddWeaponToPlayer( client, WP_K43, GetAmmoTableData(WP_K43)->defaultStartingAmmo, GetAmmoTableData(WP_K43)->defaultStartingClip, qtrue ) ) {
-						AddWeaponToPlayer( client, WP_K43_SCOPE, GetAmmoTableData(WP_K43_SCOPE)->defaultStartingAmmo, GetAmmoTableData(WP_K43_SCOPE)->defaultStartingClip, qfalse );
-					}
-					break;
-				} else {
-					if( AddWeaponToPlayer( client, WP_GARAND, GetAmmoTableData(WP_GARAND)->defaultStartingAmmo, GetAmmoTableData(WP_GARAND)->defaultStartingClip, qtrue ) ) {
-						AddWeaponToPlayer( client, WP_GARAND_SCOPE, GetAmmoTableData(WP_GARAND_SCOPE)->defaultStartingAmmo, GetAmmoTableData(WP_GARAND_SCOPE)->defaultStartingClip, qfalse );
-					}
-					break;
-				}
-			case WP_FG42:
-				if( AddWeaponToPlayer( client, WP_FG42, GetAmmoTableData(WP_FG42)->defaultStartingAmmo, GetAmmoTableData(WP_FG42)->defaultStartingClip, qtrue ) ) {
-					AddWeaponToPlayer( client, WP_FG42SCOPE, GetAmmoTableData(WP_FG42SCOPE)->defaultStartingAmmo, GetAmmoTableData(WP_FG42SCOPE)->defaultStartingClip, qfalse );
-				}
-				break;
-			default:
-				AddWeaponToPlayer( client, WP_STEN, 2*(GetAmmoTableData(WP_STEN)->defaultStartingAmmo), GetAmmoTableData(WP_STEN)->defaultStartingClip, qtrue );
-				break;
-			}
-
-			if( AddWeaponToPlayer( client, WP_BINOCULARS, 1, 0, qfalse ) ) {
-				client->ps.stats[STAT_KEYS] |= ( 1 << INV_BINOCS );
-			}
-
-			AddWeaponToPlayer( client, WP_SMOKE_BOMB, GetAmmoTableData(WP_SMOKE_BOMB)->defaultStartingAmmo,  GetAmmoTableData(WP_SMOKE_BOMB)->defaultStartingClip, qfalse );	
-
-			// See if we already have a satchel charge placed - NOTE: maybe we want to change this so the thing voids on death
-			if( G_FindSatchel( &g_entities[client->ps.clientNum] ) ) {
-				AddWeaponToPlayer( client, WP_SATCHEL, 0, 0, qfalse );		// Big Bang \o/
-				AddWeaponToPlayer( client, WP_SATCHEL_DET, 0, 1, qfalse );	// Big Red Button for tha Big Bang
-			} else {
-				AddWeaponToPlayer( client, WP_SATCHEL, 0, 1, qfalse );		// Big Bang \o/
-				AddWeaponToPlayer( client, WP_SATCHEL_DET, 0, 0, qfalse );	// Big Red Button for tha Big Bang
-			}
-		}
-
-		switch( client->sess.sessionTeam ) {
-			case TEAM_AXIS:
-				switch( pc ) {
-					case PC_SOLDIER:
-						if( client->sess.skill[SK_HEAVY_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_MP40 ) {
-							AddWeaponToPlayer( client, WP_MP40, 2*(GetAmmoTableData(WP_MP40)->defaultStartingAmmo), GetAmmoTableData(WP_MP40)->defaultStartingClip, qtrue );
-						} else if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_AKIMBO_LUGER ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_LUGER))] = GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_LUGER, GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_LUGER, GetAmmoTableData(WP_LUGER)->defaultStartingAmmo, GetAmmoTableData(WP_LUGER)->defaultStartingClip, qfalse );
-						}
-						break;
-
-					case PC_COVERTOPS:
-						if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && ( client->sess.playerWeapon2 == WP_AKIMBO_SILENCEDLUGER || client->sess.playerWeapon2 == WP_AKIMBO_LUGER ) ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_SILENCEDLUGER))] = GetAmmoTableData(WP_AKIMBO_SILENCEDLUGER)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_SILENCEDLUGER, GetAmmoTableData(WP_AKIMBO_SILENCEDLUGER)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_SILENCEDLUGER)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_LUGER, GetAmmoTableData(WP_LUGER)->defaultStartingAmmo, GetAmmoTableData(WP_LUGER)->defaultStartingClip, qfalse );
-							AddWeaponToPlayer( client, WP_SILENCER, GetAmmoTableData(WP_SILENCER)->defaultStartingAmmo, GetAmmoTableData(WP_SILENCER)->defaultStartingClip, qfalse );
-							client->pmext.silencedSideArm = 1;
-						}
-						break;
-
-					default:
-						if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_AKIMBO_LUGER ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_LUGER))] = GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_LUGER, GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_LUGER)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_LUGER, GetAmmoTableData(WP_LUGER)->defaultStartingAmmo, GetAmmoTableData(WP_LUGER)->defaultStartingClip, qfalse );
-						}
-						break;
-				}
-				break;
-			default:
-				switch( pc ) {
-					case PC_SOLDIER:
-						if( client->sess.skill[SK_HEAVY_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_THOMPSON ) {
-							AddWeaponToPlayer( client, WP_THOMPSON, 2*(GetAmmoTableData(WP_THOMPSON)->defaultStartingAmmo), GetAmmoTableData(WP_THOMPSON)->defaultStartingClip, qtrue );
-						} else if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_AKIMBO_COLT ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_COLT))] = GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_COLT, GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_COLT, GetAmmoTableData(WP_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_COLT)->defaultStartingClip, qfalse );
-						}
-						break;
-
-					case PC_COVERTOPS:
-						if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && ( client->sess.playerWeapon2 == WP_AKIMBO_SILENCEDCOLT || client->sess.playerWeapon2 == WP_AKIMBO_COLT ) ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_SILENCEDCOLT))] = GetAmmoTableData(WP_AKIMBO_SILENCEDCOLT)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_SILENCEDCOLT, GetAmmoTableData(WP_AKIMBO_SILENCEDCOLT)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_SILENCEDCOLT)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_COLT, GetAmmoTableData(WP_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_COLT)->defaultStartingClip, qfalse );
-							AddWeaponToPlayer( client, WP_SILENCED_COLT, GetAmmoTableData(WP_SILENCED_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_SILENCED_COLT)->defaultStartingClip, qfalse );
-							client->pmext.silencedSideArm = 1;
-						}
-						break;
-
-					default:
-						if( client->sess.skill[SK_LIGHT_WEAPONS] >= 4 && client->sess.playerWeapon2 == WP_AKIMBO_COLT ) {
-							client->ps.ammoclip[BG_FindClipForWeapon(BG_AkimboSidearm(WP_AKIMBO_COLT))] = GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingClip;
-							AddWeaponToPlayer( client, WP_AKIMBO_COLT, GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_AKIMBO_COLT)->defaultStartingClip, qfalse );
-						} else {
-							AddWeaponToPlayer( client, WP_COLT, GetAmmoTableData(WP_COLT)->defaultStartingAmmo, GetAmmoTableData(WP_COLT)->defaultStartingClip, qfalse );
-						}
-						break;
-				}
-		}
-
-		if( pc == PC_SOLDIER ) {
-			if( client->sess.sessionTeam == TEAM_AXIS ) {
-				AddWeaponToPlayer( client, WP_GRENADE_LAUNCHER,  0, 4, qfalse );
-			} else {
-				AddWeaponToPlayer( client, WP_GRENADE_PINEAPPLE, 0, 4, qfalse );
-			}
-		}
-		if( pc == PC_COVERTOPS ) {
-			if( client->sess.sessionTeam == TEAM_AXIS ) {
-				AddWeaponToPlayer( client, WP_GRENADE_LAUNCHER,  0, 2, qfalse );
-			} else {
-				AddWeaponToPlayer( client, WP_GRENADE_PINEAPPLE, 0, 2, qfalse );
-			}
-		}
-	} else {
-		// Knifeonly block
-		if( pc == PC_MEDIC ) {
-			AddWeaponToPlayer( client, WP_MEDIC_SYRINGE, 0, 20, qfalse );
-			if( client->sess.skill[SK_FIRST_AID] >= 4 )
-				AddWeaponToPlayer( client, WP_MEDIC_ADRENALINE, 0, 10, qfalse );
-
-		}
-		// End Knifeonly stuff -- Ensure that medics get their basic stuff
+	switch(pc) {
+		case PC_SOLDIER:
+			_SetSoldierSpawnWeapons(client);
+			break;
+		case PC_MEDIC:
+			_SetMedicSpawnWeapons(client);
+			break;
+		case PC_ENGINEER:
+			_SetEngineerSpawnWeapons(client);
+			break;
+		case PC_FIELDOPS:
+			_SetFieldOpSpawnWeapons(client);
+			break;
+		case PC_COVERTOPS:
+			_SetCovertSpawnWeapons(client);
+			break;
 	}
+
+	G_AddClassSpecificTools(client);
 }
 
 int G_CountTeamMedics( team_t team, qboolean alivecheck ) {
@@ -1325,6 +1625,11 @@
 		}
 	}
 
+	// look for cg_hitsounds
+	s = Info_ValueForKey(userinfo, "cg_hitsounds");
+	if(*s) client->pers.hitsounds = atoi(s);
+	else client->pers.hitsounds = 1;
+	
 	// set name
 	Q_strncpyz( oldname, client->pers.netname, sizeof( oldname ) );
 	s = Info_ValueForKey (userinfo, "name");
@@ -1415,8 +1720,15 @@
 		return;
 	}
 
-	G_LogPrintf( "ClientUserinfoChanged: %i %s\n", clientNum, s );
-	G_DPrintf( "ClientUserinfoChanged: %i :: %s\n", clientNum, s );
+	if (g_logOptions.integer & LOGOPTS_GUID) // Log the GUIDs?
+	{
+		char *guid = Info_ValueForKey ( userinfo, "cl_guid" );
+		G_LogPrintf( "ClientUserinfoChangedGUID: %i %s %s\n", clientNum, guid, s );
+		G_DPrintf( "ClientUserinfoChangedGUID: %i :: %s %s\n", clientNum, guid, s );
+	} else {
+		G_LogPrintf( "ClientUserinfoChanged: %i %s\n", clientNum, s );
+		G_DPrintf( "ClientUserinfoChanged: %i :: %s\n", clientNum, s );
+	}
 }
 
 
@@ -1444,11 +1756,12 @@
 	char		*value;
 	gclient_t	*client;
 	char		userinfo[MAX_INFO_STRING];
+	char		userinfo2[MAX_INFO_STRING];
 	gentity_t	*ent;
-#ifdef USEXPSTORAGE
-	ipXPStorage_t* xpBackup;
-	int			i;
-#endif // USEXPSTORAGE
+	int		i;
+      	int	 	clientNum2;
+	char		guid[33];
+
 
 	ent = &g_entities[ clientNum ];
 
@@ -1463,6 +1776,11 @@
 		return "You are banned from this server.";
 	}
 
+	// check for shrubbot ban
+	if(G_shrubbot_ban_check(userinfo)) 
+		return "You are banned from this server.";
+	
+
 	// Xian - check for max lives enforcement ban
 	if( g_gametype.integer != GT_WOLF_LMS ) {
 		if( g_enforcemaxlives.integer && (g_maxlives.integer > 0 || g_axismaxlives.integer > 0 || g_alliedmaxlives.integer > 0) ) {
@@ -1502,6 +1820,33 @@
 		ClientDisconnect( ent-g_entities );
 	}
 
+	// tjw: if the client has crashed, force disconnect of previous
+	//      session so that the XP can be reclaimed
+	// tjw: this interferes with sv_wwwDlDisconnected
+	if((g_XPSave.integer & XPSF_ENABLE) &&
+		firstTime &&
+		(!trap_Cvar_VariableIntegerValue("sv_wwwDlDisconnected") ||
+		 (g_XPSave.integer & XPSF_WIPE_DUP_GUID))) {
+
+		value = Info_ValueForKey (userinfo, "cl_guid");
+		Q_strncpyz(guid, value, sizeof(guid));
+		for (i = 0; i < level.numConnectedClients; i++) {
+			clientNum2 = level.sortedClients[i];
+			if(clientNum == clientNum2) continue;
+			trap_GetUserinfo(clientNum2,
+				userinfo2,
+				sizeof(userinfo2));
+			value = Info_ValueForKey (userinfo2, "cl_guid");
+			if(!Q_stricmp(guid, value)) { 
+				G_LogPrintf( "Forcing disconnect of "
+					"duplicate guid %s for client %i\n", 
+					guid,
+					clientNum2);
+				ClientDisconnect(clientNum2);
+			}
+		}
+	}
+
 	// they can connect
 	ent->client = level.clients + clientNum;
 	client = ent->client;
@@ -1513,11 +1858,10 @@
 	client->pers.connected = CON_CONNECTING;
 	client->pers.connectTime = level.time;			// DHM - Nerve
 
-	if( firstTime )
-		client->pers.initialSpawn = qtrue;				// DHM - Nerve
-
 	// read or initialize the session data
 	if( firstTime ) {
+		client->pers.lastTeamChangeTime = 0;
+		client->pers.initialSpawn = qtrue;				// DHM - Nerve
 		G_InitSessionData( client, userinfo );
 		client->pers.enterTime = level.time;
 		client->ps.persistant[PERS_SCORE] = 0;
@@ -1525,15 +1869,39 @@
 		G_ReadSessionData( client );
 	}
 
-#ifdef USEXPSTORAGE
-	value = Info_ValueForKey (userinfo, "ip");
-	if( xpBackup = G_FindXPBackup( value ) ) {
-		for( i = 0; i < SK_NUM_SKILLS; i++ ) {
-			client->sess.skillpoints[ i ] = xpBackup->skills[ i ];
+	
+	if(g_XPSave.integer & XPSF_ENABLE) {
+
+		char *guid;
+		char userinfo[MAX_INFO_STRING];
+		XPStorage_t* storage;
+		int i;
+		
+		client->XPSave_lives = -999;
+		trap_GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );
+		guid = Info_ValueForKey ( userinfo, "cl_guid" );
+		storage = G_FindXPBackup(guid);
+		if(storage) {
+			// make the client aware that they have no lives before
+			// ClientBegin to avoid confusion
+			if(storage->lives != -999 &&
+				storage->lives < 0) {
+
+				client->ps.persistant[PERS_RESPAWNS_LEFT] = storage->lives;
+
+			}
+			client->XPSave_lives = storage->lives;
+			for( i = 0; i < SK_NUM_SKILLS; i++ ) {
+				client->sess.skillpoints[i] = storage->skills[i];
+			}
+			G_CalcRank( client );
+			ent->client->ps.stats[STAT_XP] = 0;
+			for( i = 0; i < SK_NUM_SKILLS; i++ ) {
+				ent->client->ps.stats[STAT_XP] += ent->client->sess.skillpoints[i];
+			}
+			BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
 		}
-		G_CalcRank( client );
 	}
-#endif // USEXPSTORAGE
 
 	if( g_gametype.integer == GT_WOLF_CAMPAIGN ) {
 		if( g_campaigns[level.currentCampaign].current == 0 || level.newCampaign ) {
@@ -1625,10 +1993,25 @@
 //
 int G_ComputeMaxLives(gclient_t *cl, int maxRespawns)
 {
-	float scaled = (float)(maxRespawns - 1) * (1.0f - ((float)(level.time - level.startTime) / (g_timelimit.value * 60000.0f)));
-	int val = (int)scaled;
+	float scaled;
+	int val;
+
+	// tjw: do not give out lives in dual obj maps once time runs out.
+	if((float)(level.time - level.startTime) >= (g_timelimit.value * 60000.0f))
+		return -1;
+
+	scaled = (float)(maxRespawns - 1) * (1.0f - ((float)(level.time - level.startTime) / (g_timelimit.value * 60000.0f)));
+	val = (int)scaled;
 
 	val += ((scaled - (float)val) < 0.5f) ? 0 : 1;
+
+	if((g_XPSave.integer & XPSF_ENABLE) && 
+		cl->XPSave_lives != -999 &&
+		cl->XPSave_lives < val) {
+
+		val = cl->XPSave_lives;
+	}
+
 	return(val);
 }
 
@@ -1647,11 +2030,19 @@
 	gclient_t	*client;
 	int			flags;
 	int			spawn_count, lives_left;		// DHM - Nerve
+	int			health;
+	qboolean	maxlives;
 
 	ent = g_entities + clientNum;
 
 	client = level.clients + clientNum;
 
+	health = ent->health;
+
+	maxlives = (g_maxlives.integer || 
+		g_alliedmaxlives.integer || 
+		g_axismaxlives.integer);
+
 	if ( ent->r.linked ) {
 		trap_UnlinkEntity( ent );
 	}
@@ -1676,14 +2067,26 @@
 	memset( &client->ps, 0, sizeof( client->ps ) );
 	client->ps.eFlags = flags;
 	client->ps.persistant[PERS_SPAWN_COUNT] = spawn_count;
-	client->ps.persistant[PERS_RESPAWNS_LEFT] = lives_left;
+	if(!maxlives)
+		client->ps.persistant[PERS_RESPAWNS_LEFT] = -1;
+	else
+		client->ps.persistant[PERS_RESPAWNS_LEFT] = lives_left;
 	
 
 	client->pers.complaintClient = -1;
 	client->pers.complaintEndTime = -1;
 
-	// locate ent at a spawn point
-	ClientSpawn( ent, qfalse );
+	// tjw: even if g_teamChangeKills is 0, kill them if they try to
+	//      change teams twice in one round to prevent team change
+	//      spamming.
+	if(client->sess.sessionTeam == TEAM_AXIS) {
+		if(level.time - client->pers.lastTeamChangeTime < g_redlimbotime.integer)
+			health = 0;
+	}
+	if(client->sess.sessionTeam == TEAM_ALLIES) {
+		if(level.time - client->pers.lastTeamChangeTime < g_bluelimbotime.integer)
+			health = 0;
+	}
 
 	// Xian -- Changed below for team independant maxlives
 	if( g_gametype.integer != GT_WOLF_LMS ) {
@@ -1721,27 +2124,37 @@
  				}
 			}
 		}
-	}	
+	}
 
+	// locate ent at a spawn point
+	if(!g_teamChangeKills.integer && health > 0) { 
 
-	// DHM - Nerve :: Start players in limbo mode if they change teams during the match
-	if(client->sess.sessionTeam != TEAM_SPECTATOR && (level.time - level.startTime > FRAMETIME * GAME_INIT_FRAMES) ) {
-/*	  if( (client->sess.sessionTeam != TEAM_SPECTATOR && (level.time - client->pers.connectTime) > 60000) ||
-		( g_gamestate.integer == GS_PLAYING && ( client->sess.sessionTeam == TEAM_AXIS || client->sess.sessionTeam == TEAM_ALLIES ) && 
-		 g_gametype.integer == GT_WOLF_LMS && ( level.numTeamClients[0] > 0 || level.numTeamClients[1] > 0 ) ) ) {*/
-		ent->health = 0;
-		ent->r.contents = CONTENTS_CORPSE;
+		ClientSpawn(ent, qfalse, qtrue, qfalse);
+	}
+	else {
+		ClientSpawn(ent, qfalse, qtrue, qtrue);
+	}
 
-		client->ps.pm_type = PM_DEAD;
-		client->ps.stats[STAT_HEALTH] = 0;
 
-		if( g_gametype.integer != GT_WOLF_LMS ) {
-			if( g_maxlives.integer > 0 ) {
+	// DHM - Nerve :: Start players in limbo mode if they change teams 
+	// during the match
+	// tjw: don't kill the player unless they're dead already
+	if(client->sess.sessionTeam != TEAM_SPECTATOR && 
+		level.time - level.startTime > FRAMETIME * GAME_INIT_FRAMES) {
+			
+			// tjw: otherwise players lose 2 lives. 
+			// tjw: wtf does gametype have to do with it?
+			if(g_gametype.integer != GT_WOLF_LMS && maxlives)
 				client->ps.persistant[PERS_RESPAWNS_LEFT]++;
-			}
-		}
+			
+			if(health <= 0 || g_teamChangeKills.integer) {
+				ent->health = 0;
+				ent->r.contents = CONTENTS_CORPSE;
+				client->ps.pm_type = PM_DEAD;
+				client->ps.stats[STAT_HEALTH] = 0;
 
-		limbo(ent, qfalse);
+				limbo(ent, qfalse);
+			}
 	}
 
 	if(client->sess.sessionTeam != TEAM_SPECTATOR) {
@@ -1845,7 +2258,11 @@
 Initializes all non-persistant parts of playerState
 ============
 */
-void ClientSpawn( gentity_t *ent, qboolean revived )
+void ClientSpawn(
+		gentity_t *ent,
+		qboolean revived,
+		qboolean teamChange,
+		qboolean restoreHealth)
 {
 	int			index;
 	vec3_t		spawn_origin, spawn_angles;
@@ -1934,10 +2351,12 @@
 
 	{
 		qboolean set = client->maxlivescalced;
+		int XPSave_lives = client->XPSave_lives;
 
 		memset( client, 0, sizeof(*client) );
 
 		client->maxlivescalced = set;
+		client->XPSave_lives = XPSave_lives;
 	}
 
 	client->pers			= saved;
@@ -1964,6 +2383,7 @@
 
 	// clear entity values
 	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
+
 	client->ps.eFlags = flags;
 	// MrE: use capsules for AI and player
 	//client->ps.eFlags |= EF_CAPSULE;
@@ -2000,7 +2420,8 @@
 	client->ps.standViewHeight = DEFAULT_VIEWHEIGHT;
 	client->ps.deadViewHeight = DEAD_VIEWHEIGHT;
 	
-	client->ps.crouchMaxZ = client->ps.maxs[2] - (client->ps.standViewHeight - client->ps.crouchViewHeight);
+	//client->ps.crouchMaxZ = client->ps.maxs[2] - (client->ps.standViewHeight - client->ps.crouchViewHeight);
+	client->ps.crouchMaxZ = CROUCH_VIEWHEIGHT; 
 
 	client->ps.runSpeedScale = 0.8;
 	client->ps.sprintSpeedScale = 1.1;
@@ -2036,7 +2457,7 @@
 
 		client->sess.playerType = client->sess.latchPlayerType;
 
-		if( G_IsWeaponDisabled( ent, client->sess.latchPlayerWeapon ) ) {
+		if( G_IsWeaponDisabled( ent, client->sess.latchPlayerWeapon, qtrue ) ) {
 			bg_playerclass_t* classInfo = BG_PlayerClassForPlayerState( &ent->client->ps );
 			client->sess.latchPlayerWeapon = classInfo->classWeapons[0];
 			update = qtrue;
@@ -2047,7 +2468,7 @@
 			update = qtrue;
 		}
 
-		if( G_IsWeaponDisabled( ent, client->sess.playerWeapon ) ) {
+		if( G_IsWeaponDisabled( ent, client->sess.playerWeapon, qtrue ) ) {
 			bg_playerclass_t* classInfo = BG_PlayerClassForPlayerState( &ent->client->ps );
 			client->sess.playerWeapon = classInfo->classWeapons[0];
 			update = qtrue;
@@ -2055,7 +2476,7 @@
 
 		client->sess.playerWeapon2 = client->sess.latchPlayerWeapon2;
 
-		if( update ) {
+		if( update || teamChange ) {
 			ClientUserinfoChanged( index );
 		}
 	}
@@ -2065,8 +2486,10 @@
 		// Xian - Moved the invul. stuff out of SetWolfSpawnWeapons and put it here for clarity
 		if ( g_fastres.integer == 1 && revived )
 			client->ps.powerups[PW_INVULNERABLE] = level.time + 1000; 
-		else
+		else if(revived) 
 			client->ps.powerups[PW_INVULNERABLE] = level.time + 3000; 
+		else
+			client->ps.powerups[PW_INVULNERABLE] = level.time + (g_spawnInvul.integer * 1000); 
 	}
 	// End Xian
 
@@ -2089,11 +2512,16 @@
 	// JPW NERVE ***NOTE*** the following line is order-dependent and must *FOLLOW* SetWolfSpawnWeapons() in multiplayer
 	// AddMedicTeamBonus() now adds medic team bonus and stores in ps.stats[STAT_MAX_HEALTH].
 
-	if( client->sess.skill[SK_BATTLE_SENSE] >= 3 )
-		// We get some extra max health, but don't spawn with that much
-		ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] - 15;
-	else
-		ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
+	if(restoreHealth) {
+		if( client->sess.skill[SK_BATTLE_SENSE] >= 3 )
+			// We get some extra max health, but don't spawn with that much
+			ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] - 15;
+		else
+			ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
+	}
+	else {
+		client->ps.stats[STAT_HEALTH] = ent->health;
+	}
 
 	G_SetOrigin( ent, spawn_origin );
 	VectorCopy( spawn_origin, client->ps.origin );
@@ -2209,9 +2637,8 @@
 		return;
 	}
 
-#ifdef USEXPSTORAGE
-	G_AddXPBackup( ent );
-#endif // USEXPSTORAGE
+
+	if(g_XPSave.integer & XPSF_ENABLE) G_AddXPBackup( ent );
 
 	G_RemoveClientFromFireteams( clientNum, qtrue, qfalse );
 	G_RemoveFromAllIgnoreLists( clientNum );
diff -urN --exclude=.svn et.orig/src/game/g_cmds.c etpub/src/game/g_cmds.c
--- et.orig/src/game/g_cmds.c	2003-08-28 15:43:22.000000000 -0500
+++ etpub/src/game/g_cmds.c	2005-03-18 17:31:23.000000000 -0600
@@ -4,6 +4,149 @@
 void GetBotAutonomies(int clientNum, int *weapAutonomy, int *moveAutonomy);	
 qboolean G_IsOnFireteam(int entityNum, fireteamData_t** teamNum);
 
+// Josh: like shrub, pretty naive
+qboolean G_CensorText(char *text)
+{
+	qboolean foundWord = qfalse, lastWordFound = qfalse;
+	int word = 0;
+	char *textPos = text;
+	while (*textPos) {
+		lastWordFound = qfalse;
+		word = 0;
+		while (word < censorDictionary.num_words && *textPos) {
+			if(!Q_stricmp(textPos, censorDictionary.words[word])) {
+				foundWord = qtrue;
+				if (word == censorDictionary.num_words - 1) {
+					lastWordFound = qtrue;
+				}
+				{
+					int i;
+					for (i = 0; 
+					    i < strlen(
+					      censorDictionary.words[word]);
+					    i++) {
+						*textPos++ =  '*';
+					}
+				}
+			}
+			word++;
+		}
+		// If it's the last word, it will already be incremented
+		if (!lastWordFound)
+			textPos++;
+	}
+	return foundWord;
+}
+
+// Josh: Won't gib if already in limbo, same as shrub
+void G_CensorPenalize(gentity_t *ent)
+{
+	if (!ent->client) return;
+	if (g_censorPenalty.integer & CNSRPNLTY_KILL) {
+		Cmd_Kill_f(ent);
+		return;
+	}
+	if (g_censorPenalty.integer & CNSRPNLTY_NOGIB){
+		// KILL, don't GIB
+		ent->flags &= ~FL_GODMODE;
+		ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
+		ent->client->ps.persistant[PERS_HWEAPON_USE] = 0; // TTimo - if at MG42
+		player_die(ent, ent, ent , 135, MOD_UNKNOWN);
+	}
+}
+
+/*
+ * G_PlayDead
+ */
+void G_PlayDead(gentity_t *ent) 
+{
+
+	if(!ent->client) return;
+	if(!g_playDead.integer) return;
+	if(ent->health < 0) return;
+	if(ent->client->ps.eFlags & EF_PLAYDEAD) {
+
+		ent->client->ps.stats[STAT_HEALTH] = ent->health;
+		ent->client->ps.pm_type = PM_PLAYDEAD;
+		CP("cp \"SURPRISE!\" 1");
+		/*
+		BG_AnimScriptEvent(
+			&ent->client->ps,
+			ent->client->pers.character->animModelInfo,
+			ANIM_ET_JUMP,
+			qfalse,
+			qtrue);
+		*/
+	}
+	else {
+		ent->client->ps.pm_type = PM_PLAYDEAD;
+		/*
+		BG_AnimScriptEvent(
+			&ent->client->ps,
+			ent->client->pers.character->animModelInfo,
+			ANIM_ET_DEATH,
+			qfalse,
+			qtrue);
+		*/
+	}
+}
+
+void G_PrivateMessage(gentity_t *ent) 
+{
+	int pids[MAX_CLIENTS];
+	char name[MAX_NAME_LENGTH];
+	char netname[MAX_NAME_LENGTH];
+	char cmd[12];
+	char *msg;
+	int pcount;
+	int i;
+	int skipargs = 0;
+	gentity_t *tmpent;
+	qboolean sent = qfalse;
+
+	if(!g_privateMessages.integer && ent) return;
+	Q_SayArgv(0, cmd, sizeof(cmd));
+	if(!Q_stricmp(cmd, "say")) {
+		skipargs = 1;
+		Q_SayArgv(1, cmd, sizeof(cmd));
+	}
+	if(Q_SayArgc() < 3+skipargs) {
+		SP(va("usage: %s [name|slot#] [message]\n", cmd));
+		return;
+	}
+	Q_SayArgv(1+skipargs, name, sizeof(name));
+	msg = Q_SayConcatArgs(2+skipargs);
+	pcount = ClientNumbersFromString(name, pids);
+
+	if(ent)
+		Q_strncpyz(netname, 
+			ent->client->pers.netname,
+			sizeof(name));
+	else
+		Q_strncpyz(netname, "console", sizeof(name));
+
+	for(i=0; i<pcount; i++) {
+		if(pids[i] == ent-g_entities) continue;
+		sent = qtrue;
+		tmpent = &g_entities[pids[i]];
+		CPx(pids[i], va(
+			"chat \"%s^7 -> %s^7: (%d recipients^7): ^3%s^7\"",
+			netname,
+			name,
+			pcount,
+			msg));
+		CPx(pids[i], va("cp \"^3private message from ^7%s^7\"",
+			netname));
+		SP(va("private message sent to %s: ^3%s^7\n",
+			tmpent->client->pers.netname,
+			msg
+			));
+	}
+	if(!sent) {
+		SP("player not found\n");
+	}
+}
+
 /*
 ==================
 G_SendScore
@@ -136,41 +279,65 @@
 	return qtrue;
 }
 
+// josh: tjw moved the declaration to q_shared.h, q_shared.c needs this
+// so I moved it to q_shared.c
+///*
+//==================
+//ConcatArgs
+//==================
+//*/
+//char	*ConcatArgs( int start ) {
+//	int		i, c, tlen;
+//	static char	line[MAX_STRING_CHARS];
+//	int		len;
+//	char	arg[MAX_STRING_CHARS];
+//
+//	len = 0;
+//	c = trap_Argc();
+//	for ( i = start ; i < c ; i++ ) {
+//		trap_Argv( i, arg, sizeof( arg ) );
+//		tlen = strlen( arg );
+//		if ( len + tlen >= MAX_STRING_CHARS - 1 ) {
+//			break;
+//		}
+//		memcpy( line + len, arg, tlen );
+//		len += tlen;
+//		if ( i != c - 1 ) {
+//			line[len] = ' ';
+//			len++;
+//		}
+//	}
+//
+//	line[len] = 0;
+//
+//	return line;
+//}
 
 /*
 ==================
-ConcatArgs
+DecolorString
+
+Remove color characters
 ==================
 */
-char	*ConcatArgs( int start ) {
-	int		i, c, tlen;
-	static char	line[MAX_STRING_CHARS];
-	int		len;
-	char	arg[MAX_STRING_CHARS];
-
-	len = 0;
-	c = trap_Argc();
-	for ( i = start ; i < c ; i++ ) {
-		trap_Argv( i, arg, sizeof( arg ) );
-		tlen = strlen( arg );
-		if ( len + tlen >= MAX_STRING_CHARS - 1 ) {
-			break;
-		}
-		memcpy( line + len, arg, tlen );
-		len += tlen;
-		if ( i != c - 1 ) {
-			line[len] = ' ';
-			len++;
+void DecolorString( char *in, char *out)
+{
+	while(*in) {
+		if(*in == 27 || *in == '^') {
+			in++;		// skip color code
+			if(*in) in++;
+			continue;
 		}
+		*out++ = *in++;
 	}
-
-	line[len] = 0;
-
-	return line;
+	*out = 0;
 }
 
 /*
 ==================
+
+/*
+==================
 SanitizeString
 
 Remove case and control characters
@@ -198,6 +365,62 @@
 
 /*
 ==================
+ClientNumbersFromString
+
+Sets plist to an array of integers that represent client numbers that have 
+names that are a partial match for s. List is terminated by a -1.
+
+Returns number of matching clientids.
+==================
+*/
+int ClientNumbersFromString( char *s, int *plist) {
+	gclient_t *p;
+	int i, found = 0;
+	char s2[MAX_STRING_CHARS];
+	char n2[MAX_STRING_CHARS];
+	char *m;
+	qboolean is_slot = qtrue;
+
+	*plist = -1;
+
+	// if a number is provided, it might be a slot # 
+	for(i=0; i<strlen(s); i++) { 
+		if(s[i] < '0' || s[i] > '9') {
+			is_slot = qfalse;
+			break;
+		}
+	}
+	if(is_slot) {
+		i = atoi(s);
+		if(i >= 0 && i < level.maxclients) {
+			p = &level.clients[i];
+			if(p->pers.connected == CON_CONNECTED) {
+				*plist++ = i;
+				*plist = -1;
+				return 1;
+			}
+		}
+	}
+
+	// now look for name matches
+	SanitizeString(s, s2, qtrue);
+	if(strlen(s2) < 1) return 0;
+	for(i=0; i < level.maxclients; i++) {
+		p = &level.clients[i];
+		if(p->pers.connected != CON_CONNECTED) continue;
+		SanitizeString(p->pers.netname, n2, qtrue);
+		m = strstr(n2, s2);
+		if(m != NULL) {
+			*plist++ = i;
+			found++;
+		}
+	}
+	*plist = -1;
+	return found;
+}
+	
+/*
+==================
 ClientNumberFromString
 
 Returns a player number for either a number or name string
@@ -672,6 +895,38 @@
 	}
 }
 
+
+void G_DropItems(gentity_t *self) 
+{
+	gitem_t *item= NULL;
+
+	// drop flag regardless
+	if (self->client->ps.powerups[PW_REDFLAG]) {
+		item = BG_FindItem("Red Flag");
+		if (!item)
+			item = BG_FindItem("Objective");
+
+		self->client->ps.powerups[PW_REDFLAG] = 0;
+	}
+	if (self->client->ps.powerups[PW_BLUEFLAG]) {
+		item = BG_FindItem("Blue Flag");
+		if (!item)
+			item = BG_FindItem("Objective");
+
+		self->client->ps.powerups[PW_BLUEFLAG] = 0;
+	}
+
+	if (item) {
+		vec3_t launchvel = { 0, 0, 0 };
+		gentity_t *flag = LaunchItem(item, self->r.currentOrigin, launchvel, self->s.number);
+
+		flag->s.modelindex2 = self->s.otherEntityNum2;// JPW NERVE FIXME set player->otherentitynum2 with old modelindex2 from flag and restore here
+		flag->message = self->message;	// DHM - Nerve :: also restore item name
+		// Clear out player's temp copies
+		self->s.otherEntityNum2 = 0;
+		self->message = NULL;
+	}
+}
 /*
 =================
 SetTeam
@@ -685,6 +940,11 @@
 	int					specClient;
 	int					respawnsLeft;
 
+	// if the team changing player is a shrubbot admin with the
+	// '5' flag, they can switch teams regardless of balance
+	if(G_shrubbot_permission(ent, SBF_FORCETEAMCHANGE)) 
+		force = qtrue;
+
 	//
 	// see what change is requested
 	//
@@ -788,14 +1048,22 @@
 		client->pers.teamState.state = TEAM_BEGIN;
 	}
 	
-	if ( oldTeam != TEAM_SPECTATOR ) {
-		if ( !(ent->client->ps.pm_flags & PMF_LIMBO) ) {
-			// Kill him (makes sure he loses flags, etc)
-			ent->flags &= ~FL_GODMODE;
+
+	if(oldTeam != TEAM_SPECTATOR && 
+		!(ent->client->ps.pm_flags & PMF_LIMBO) ) {
+		
+		ent->flags &= ~FL_GODMODE;
+		// tjw: if they're not dead, don't kill
+		if(g_teamChangeKills.integer || ent->health <= 0) {
 			ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
 			player_die (ent, ent, ent, 100000, MOD_SWITCHTEAM);
 		}
+		else {
+			ent->client->ps.stats[STAT_HEALTH] = ent->health;
+			G_DropItems(ent);
+		}
 	}
+
 	// they go to the end of the line for tournements
 	if ( team == TEAM_SPECTATOR ) {
 		client->sess.spectatorTime = level.time;
@@ -866,10 +1134,12 @@
 	G_verifyMatchState(oldTeam);
 	BotRecordTeamChange( clientNum );
 
+	/*
 	// Reset stats when changing teams
 	if(team != oldTeam) {
 		G_deleteStats(clientNum);
 	}
+	*/
 
 	G_UpdateSpawnCounts();
 
@@ -910,7 +1180,7 @@
 			}
 		}
 	}
-
+	ent->client->pers.lastTeamChangeTime = level.time;
 	return qtrue;
 }
 
@@ -1029,24 +1299,62 @@
 	return cnt;
 }
 
-qboolean G_IsWeaponDisabled( gentity_t* ent, weapon_t weapon ) {
+qboolean G_IsWeaponDisabled( gentity_t* ent, weapon_t weapon, qboolean quiet ) {
 	int count, wcount;
 
 	if( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
 		return qtrue;
 	}
 
-	if( !G_IsHeavyWeapon( weapon ) ) {
-		return qfalse;
-	}
-
 	count =		G_TeamCount( ent, -1 );
 	wcount =	G_TeamCount( ent, weapon );
 
-	if( wcount >= ceil( count * g_heavyWeaponRestriction.integer * 0.01f ) ) {
-		return qtrue;
+	if(G_IsHeavyWeapon(weapon)) {
+		if( wcount >= ceil( count * g_heavyWeaponRestriction.integer * 0.01f ) ) {
+			return qtrue;
+		}
+	}
+
+	switch(weapon) {
+	case WP_PANZERFAUST:
+		if(team_maxPanzers.integer == -1) return qfalse;
+		if(wcount >= team_maxPanzers.integer) {
+			if(!quiet)
+				CP("cp \"^1PANZERFAUST not available^7\" 1");
+			return qtrue;
+		}
+	case WP_MOBILE_MG42:
+		if(team_maxMG42s.integer == -1) return qfalse;
+		if(wcount >= team_maxMG42s.integer) {
+			if(!quiet) 
+				CP("cp \"^1MG42 not available^7\" 1");
+			return qtrue;
+		}
+	case WP_FLAMETHROWER:
+		if(team_maxFlamers.integer == -1) return qfalse;
+		if(wcount >= team_maxFlamers.integer) {
+			CP("cp \"^1FLAMETHROWER not available^7\" 1");
+			return qtrue;
+		}
+	case WP_MORTAR:
+		if(team_maxMortars.integer == -1) return qfalse;
+		if(wcount >= team_maxMortars.integer) {
+			if(!quiet) 
+				CP("cp \"^1MORTAR not available^7\" 1");
+			return qtrue;
+		}
+	case WP_GPG40:
+	case WP_CARBINE:
+		if(team_maxGrenLaunchers.integer == -1) return qfalse;
+		if(wcount >= team_maxGrenLaunchers.integer) {
+			if(!quiet)
+				CP("cp \"^1GRENADE LAUNCHER not available^7\" 1");
+			return qtrue;
+		}
 	}
 
+
+
 	return qfalse;
 }
 
@@ -1058,7 +1366,7 @@
 		changed = qtrue;
 	}
 
-	if( !G_IsWeaponDisabled( ent, w1 ) ) {
+	if( !G_IsWeaponDisabled( ent, w1, qfalse ) ) {
 		if( ent->client->sess.latchPlayerWeapon != w1 ) {
 			ent->client->sess.latchPlayerWeapon = w1;
 			changed = qtrue;
@@ -1067,7 +1375,7 @@
 		if( ent->client->sess.latchPlayerWeapon != 0 ) {
 			ent->client->sess.latchPlayerWeapon = 0;
 			changed = qtrue;
-		}		
+		}
 	}
 
 	if( updateclient && changed ) {
@@ -1087,6 +1395,7 @@
 	char		weap[4], weap2[4];
 	weapon_t	w, w2;
 
+
 	if ( trap_Argc() < 2 ) {
 		char *pszTeamName;
 
@@ -1117,14 +1426,30 @@
 
 	w =		atoi( weap );
 	w2 =	atoi( weap2 );
+	
+	// tjw: this is a dirty dirty hack to work around a client
+	// 	bug that moves players to soldier smg players 
+	// 	if they have lvl 4 heavy or light weapons.
+	// 	this could be fixed with a client mod
+	if((ent->client->sess.skill[SK_HEAVY_WEAPONS] >= 4 ||
+		ent->client->sess.skill[SK_LIGHT_WEAPONS] >= 4) &&
+		(level.time - ent->client->pers.connectTime) < 60000 &&
+		*s == 's') {
+
+		ent->client->ps.pm_flags &= ~PMF_LIMBO;	
+		return;
+	}
 
-	ent->client->sess.latchPlayerType =	atoi( ptype );
-	if( ent->client->sess.latchPlayerType < PC_SOLDIER || ent->client->sess.latchPlayerType > PC_COVERTOPS ) {
-		ent->client->sess.latchPlayerType = PC_SOLDIER;
+	// tjw: allow old-school q2 players to use the '/team r' 
+	//      or '/team b' commands without losing their class
+	if(*ptype) {
+		ent->client->sess.latchPlayerType =	atoi( ptype );
 	}
+	
+	if( ent->client->sess.latchPlayerType < PC_SOLDIER ||
+			ent->client->sess.latchPlayerType > PC_COVERTOPS ) {
 
-	if( ent->client->sess.latchPlayerType < PC_SOLDIER || ent->client->sess.latchPlayerType > PC_COVERTOPS ) {
-		ent->client->sess.latchPlayerType = PC_SOLDIER;
+			ent->client->sess.latchPlayerType = PC_SOLDIER;
 	}
 
 	if( !SetTeam( ent, s, qfalse, w, w2, qtrue ) ) {
@@ -1394,7 +1719,6 @@
 G_Say
 ==================
 */
-#define	MAX_SAY_TEXT	150
 
 void G_SayTo( gentity_t *ent, gentity_t *other, int mode, int color, const char *name, const char *message, qboolean localize )
 {
@@ -1437,38 +1761,49 @@
 	char		name[64];
 	// don't let text be too long for malicious reasons
 	char		text[MAX_SAY_TEXT];
+	char		censoredText[MAX_SAY_TEXT];
 	qboolean	localize = qfalse;
 	char		*loc;
 
+	Q_strncpyz( text, chatText, sizeof(text) );
+	if (g_censor.string[0]) {
+		SanitizeString(text, censoredText, qtrue);
+		if (G_CensorText(censoredText)) {
+			// like shrub, if the text is censored, 
+			// it becomes colorless
+			Q_strncpyz( text, censoredText, sizeof(text) );
+			G_CensorPenalize(ent);
+		}
+	}
+
 	switch ( mode ) {
 	default:
 	case SAY_ALL:
-		G_LogPrintf( "say: %s: %s\n", ent->client->pers.netname, chatText );
+		G_LogPrintf( "say: %s: %s\n", ent->client->pers.netname, text );
 		Com_sprintf (name, sizeof(name), "%s%c%c: ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
 		color = COLOR_GREEN;
 		break;
 	case SAY_BUDDY:
 		localize = qtrue;
-		G_LogPrintf( "saybuddy: %s: %s\n", ent->client->pers.netname, chatText );
+		G_LogPrintf( "saybuddy: %s: %s\n", ent->client->pers.netname, text );
 		loc = BG_GetLocationString( ent->r.currentOrigin );
 		Com_sprintf (name, sizeof(name), "[lof](%s%c%c) (%s): ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE, loc);
 		color = COLOR_YELLOW;
 		break;
 	case SAY_TEAM:
 		localize = qtrue;
-		G_LogPrintf( "sayteam: %s: %s\n", ent->client->pers.netname, chatText );
+		G_LogPrintf( "sayteam: %s: %s\n", ent->client->pers.netname, text );
 		loc = BG_GetLocationString( ent->r.currentOrigin );
 		Com_sprintf (name, sizeof(name), "[lof](%s%c%c) (%s): ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE, loc);
 		color = COLOR_CYAN;
 		break;
 	case SAY_TEAMNL:
-		G_LogPrintf( "sayteamnl: %s: %s\n", ent->client->pers.netname, chatText );
+		G_LogPrintf( "sayteamnl: %s: %s\n", ent->client->pers.netname, text );
 		Com_sprintf (name, sizeof(name), "(%s^7): ", ent->client->pers.netname);
 		color = COLOR_CYAN;
 		break;
 	}
 
-	Q_strncpyz( text, chatText, sizeof(text) );
 
 	if ( target ) {
 		if( !(target->client->sess.ignoreClients[(ent-g_entities) / 8] & (1 << ((ent-g_entities) % 8))) ) {
@@ -1489,6 +1824,8 @@
 			G_SayTo( ent, other, mode, color, name, text, localize );
 		}
 	}
+
+	G_shrubbot_cmd_check(ent);
 }
 
 
@@ -1500,7 +1837,13 @@
 void Cmd_Say_f( gentity_t *ent, int mode, qboolean arg0 )
 {
 	if(trap_Argc() < 2 && !arg0) return;
-	G_Say(ent, NULL, mode, ConcatArgs(((arg0) ? 0 : 1)));
+	if(g_privateMessages.integer &&
+		strstr(Q_SayConcatArgs(0), "say /m ")) {
+
+		G_PrivateMessage(ent);
+	}
+	else
+		G_Say(ent, NULL, mode, ConcatArgs(((arg0) ? 0 : 1)));
 }
 
 extern void BotRecordVoiceChat( int client, int destclient, const char *id, int mode, qboolean noResponse );
@@ -2414,55 +2757,272 @@
 // Rafael
 /*
 ==================
-Cmd_Activate_f
+G_UniformSteal formerly known as Cmd_Activate2_f
 ==================
 */
-qboolean Do_Activate2_f(gentity_t *ent, gentity_t *traceEnt) {
+qboolean G_UniformSteal(gentity_t *ent, gentity_t *traceEnt) 
+{
 	qboolean found = qfalse;
+	if(traceEnt->activator) return qfalse; // already used corpse
+	if(ent->client->sess.playerType != PC_COVERTOPS)
+		return qfalse;
+	if(ent->client->ps.powerups[PW_OPS_DISGUISED])
+		return qfalse;
+	if(ent->client->ps.powerups[PW_BLUEFLAG] || 
+		ent->client->ps.powerups[PW_REDFLAG])
+		return qfalse;
+	if(BODY_TEAM(traceEnt) == ent->client->sess.sessionTeam)
+		return qfalse;
+	if( BODY_VALUE(traceEnt) < 250 ) {
+		BODY_VALUE(traceEnt) += 5;
+		return qfalse;
+	}
 
-	if( ent->client->sess.playerType == PC_COVERTOPS && !ent->client->ps.powerups[PW_OPS_DISGUISED] ) {
-		if( !ent->client->ps.powerups[PW_BLUEFLAG] && !ent->client->ps.powerups[PW_REDFLAG] ) {
-			if( traceEnt->s.eType == ET_CORPSE ) {
-				if( BODY_TEAM(traceEnt) < 4 && BODY_TEAM(traceEnt) != ent->client->sess.sessionTeam ) {
-					found = qtrue;
+	traceEnt->nextthink = traceEnt->timestamp + BODY_TIME(BODY_TEAM(traceEnt));
 
-					if( BODY_VALUE(traceEnt) >= 250 ) {
+	//BG_AnimScriptEvent( &ent->client->ps, ent->client->pers.character->animModelInfo, ANIM_ET_PICKUPGRENADE, qfalse, qtrue );
+	//ent->client->ps.pm_flags |= PMF_TIME_LOCKPLAYER;
+	//ent->client->ps.pm_time = 2100;
 
-						traceEnt->nextthink = traceEnt->timestamp + BODY_TIME(BODY_TEAM(traceEnt));
-			
-//						BG_AnimScriptEvent( &ent->client->ps, ent->client->pers.character->animModelInfo, ANIM_ET_PICKUPGRENADE, qfalse, qtrue );
-//						ent->client->ps.pm_flags |= PMF_TIME_LOCKPLAYER;
-//						ent->client->ps.pm_time = 2100;
+	ent->client->ps.powerups[PW_OPS_DISGUISED] = 1;
+	ent->client->ps.powerups[PW_OPS_CLASS_1] = BODY_CLASS(traceEnt) & 1;
+	ent->client->ps.powerups[PW_OPS_CLASS_2] = BODY_CLASS(traceEnt) & 2;
+	ent->client->ps.powerups[PW_OPS_CLASS_3] = BODY_CLASS(traceEnt) & 4;
 
-						ent->client->ps.powerups[PW_OPS_DISGUISED] = 1;
-						ent->client->ps.powerups[PW_OPS_CLASS_1] = BODY_CLASS(traceEnt) & 1;
-						ent->client->ps.powerups[PW_OPS_CLASS_2] = BODY_CLASS(traceEnt) & 2;
-						ent->client->ps.powerups[PW_OPS_CLASS_3] = BODY_CLASS(traceEnt) & 4;
+	BODY_TEAM(traceEnt) += 4;
+	traceEnt->activator = ent;
 
-						BODY_TEAM(traceEnt) += 4;
-						traceEnt->activator = ent;
+	traceEnt->s.time2 =	1;
 
-						traceEnt->s.time2 =	1;
+	// sound effect
+	G_AddEvent( ent, EV_DISGUISE_SOUND, 0 );
 
-						// sound effect
-						G_AddEvent( ent, EV_DISGUISE_SOUND, 0 );
+	G_AddSkillPoints( ent, SK_MILITARY_INTELLIGENCE_AND_SCOPED_WEAPONS, 5.f );
+	G_DebugAddSkillPoints( ent, SK_MILITARY_INTELLIGENCE_AND_SCOPED_WEAPONS, 5, "stealing uniform" ); 
 
-						G_AddSkillPoints( ent, SK_MILITARY_INTELLIGENCE_AND_SCOPED_WEAPONS, 5.f );
-						G_DebugAddSkillPoints( ent, SK_MILITARY_INTELLIGENCE_AND_SCOPED_WEAPONS, 5, "stealing uniform" ); 
+	Q_strncpyz(ent->client->disguiseNetname,
+		g_entities[traceEnt->s.clientNum].client->pers.netname,
+		sizeof(ent->client->disguiseNetname));
+	ent->client->disguiseRank = g_entities[traceEnt->s.clientNum].client ? 
+		g_entities[traceEnt->s.clientNum].client->sess.rank : 0;
 
-						Q_strncpyz( ent->client->disguiseNetname, g_entities[traceEnt->s.clientNum].client->pers.netname, sizeof(ent->client->disguiseNetname) );
-						ent->client->disguiseRank = g_entities[traceEnt->s.clientNum].client ? g_entities[traceEnt->s.clientNum].client->sess.rank : 0;
+	ClientUserinfoChanged( ent->s.clientNum );
 
-						ClientUserinfoChanged( ent->s.clientNum );
-					} else {
-						BODY_VALUE( traceEnt ) += 5;
-					}
-				}
-			}
+
+	return qtrue;
+}
+
+/* 
+  G_ClassStealFixWeapons() //tjw
+  a helper for handling weapons for G_ClassSteal
+  */
+void G_ClassStealFixWeapons(gclient_t *client) 
+{
+	// tools
+	COM_BitClear(client->ps.weapons, WP_DYNAMITE);
+	COM_BitClear(client->ps.weapons, WP_PLIERS);
+	COM_BitClear(client->ps.weapons, WP_LANDMINE);
+	COM_BitClear(client->ps.weapons, WP_SMOKE_BOMB);
+	COM_BitClear(client->ps.weapons, WP_SATCHEL);
+	COM_BitClear(client->ps.weapons, WP_SATCHEL_DET);
+	COM_BitClear(client->ps.weapons, WP_SMOKE_MARKER);
+	COM_BitClear(client->ps.weapons, WP_AMMO);
+	COM_BitClear(client->ps.weapons, WP_MEDKIT);
+	COM_BitClear(client->ps.weapons, WP_MEDIC_SYRINGE);
+	COM_BitClear(client->ps.weapons, WP_MEDIC_ADRENALINE);
+
+	// primary weapons
+	COM_BitClear(client->ps.weapons, WP_PANZERFAUST);
+	COM_BitClear(client->ps.weapons, WP_FLAMETHROWER);
+	COM_BitClear(client->ps.weapons, WP_MOBILE_MG42);
+	COM_BitClear(client->ps.weapons, WP_MOBILE_MG42_SET);
+	COM_BitClear(client->ps.weapons, WP_MORTAR);
+	COM_BitClear(client->ps.weapons, WP_MORTAR_SET);
+	COM_BitClear(client->ps.weapons, WP_FG42);
+	COM_BitClear(client->ps.weapons, WP_FG42SCOPE);
+	COM_BitClear(client->ps.weapons, WP_K43);
+	COM_BitClear(client->ps.weapons, WP_GARAND);
+	COM_BitClear(client->ps.weapons, WP_K43_SCOPE);
+	COM_BitClear(client->ps.weapons, WP_GARAND_SCOPE);
+	COM_BitClear(client->ps.weapons, WP_STEN);
+	COM_BitClear(client->ps.weapons, WP_MP40);
+	COM_BitClear(client->ps.weapons, WP_THOMPSON);
+	COM_BitClear(client->ps.weapons, WP_KAR98);
+	COM_BitClear(client->ps.weapons, WP_GPG40);
+	COM_BitClear(client->ps.weapons, WP_CARBINE);
+	COM_BitClear(client->ps.weapons, WP_M7);
+
+	
+	// silence pistols are different than regular pistols so swap them
+	if(client->sess.playerType == PC_COVERTOPS) {
+		client->pmext.silencedSideArm = 1;
+		COM_BitSet(client->ps.weapons, WP_SILENCER);
+		COM_BitSet(client->ps.weapons, WP_SILENCED_COLT);
+		if(COM_BitCheck(client->ps.weapons, WP_AKIMBO_LUGER)) {
+			COM_BitClear(client->ps.weapons, WP_AKIMBO_LUGER);
+			COM_BitSet(client->ps.weapons, WP_AKIMBO_SILENCEDLUGER);
+		}
+		if(COM_BitCheck(client->ps.weapons, WP_AKIMBO_COLT)) {
+			COM_BitClear(client->ps.weapons, WP_AKIMBO_COLT);
+			COM_BitSet(client->ps.weapons, WP_AKIMBO_SILENCEDCOLT);
+		}
+	}
+	else {
+		client->pmext.silencedSideArm = 0;
+		COM_BitClear(client->ps.weapons, WP_SILENCER);
+		COM_BitClear(client->ps.weapons, WP_SILENCED_COLT);
+		if(COM_BitCheck(client->ps.weapons, WP_AKIMBO_SILENCEDLUGER)) {
+			COM_BitClear(client->ps.weapons, WP_AKIMBO_SILENCEDLUGER);
+			COM_BitSet(client->ps.weapons, WP_AKIMBO_LUGER);
+		}
+		if(COM_BitCheck(client->ps.weapons, WP_AKIMBO_SILENCEDCOLT)) {
+			COM_BitClear(client->ps.weapons, WP_AKIMBO_SILENCEDCOLT);
+			COM_BitSet(client->ps.weapons, WP_AKIMBO_COLT);
 		}
 	}
 
-	return found;
+	// give them all the tool-like weapons for the class
+	G_AddClassSpecificTools(client);
+}
+
+
+/*
+ G_ClassSteal //tjw
+ */
+
+qboolean G_ClassSteal(gentity_t *stealer, gentity_t *deadguy) 
+{
+	if(!g_classChange.integer) return qfalse;
+	if(deadguy->activator) return qfalse; // already used corpse
+	if( BODY_VALUE(deadguy) < 250 ) {
+		if(BODY_VALUE(deadguy) == 0) {
+			CPx(stealer->s.number, "cp \"Switching Classes\" 1");
+		}
+		BODY_VALUE(deadguy) += 5;
+		return qtrue;
+	}
+
+	deadguy->nextthink = deadguy->timestamp + BODY_TIME(BODY_TEAM(deadguy));
+
+	deadguy->activator = stealer;
+	deadguy->s.time2 =	1;
+
+	// sound effect
+	G_AddEvent(stealer, EV_DISGUISE_SOUND, 0);
+
+	// I guess this disables future use of the corpse 
+	BODY_TEAM(deadguy) += 4;
+
+	stealer->client->sess.playerType = BODY_CLASS(deadguy);
+
+
+	G_ClassStealFixWeapons(stealer->client);
+
+	// team_max[weapon] and g_heavyWeaponRestriction checks
+	if(!G_IsWeaponDisabled(stealer, BODY_WEAPON(deadguy), qtrue)) {
+		COM_BitSet(stealer->client->ps.weapons, BODY_WEAPON(deadguy));
+		stealer->client->ps.weapon = BODY_WEAPON(deadguy);
+	}
+	else if(BODY_TEAM(deadguy) == TEAM_AXIS) {
+		COM_BitSet(stealer->client->ps.weapons, WP_MP40);
+		stealer->client->ps.weapon = WP_MP40;
+	}
+	else {
+		COM_BitSet(stealer->client->ps.weapons, WP_THOMPSON);
+		stealer->client->ps.weapon = WP_THOMPSON;
+	}
+
+	// if they took a gren launching weapon, they can have the
+	// grenade launcher too I guess
+	if(COM_BitCheck(stealer->client->ps.weapons, WP_GARAND)) {
+		COM_BitSet(stealer->client->ps.weapons, WP_CARBINE);
+	}
+	else if(COM_BitCheck(stealer->client->ps.weapons, WP_K43)) {
+		COM_BitSet(stealer->client->ps.weapons, WP_GPG40);
+	}
+
+	// make sure they lose disguise when changing classes
+	stealer->client->ps.powerups[PW_OPS_DISGUISED] = 0;
+
+	ClientUserinfoChanged(stealer->s.clientNum);
+
+	return qtrue;
+}
+
+/* 
+ G_PushPlayer //tjw
+ mostly lifted from WolfRevivePushEnt
+ */
+qboolean G_PushPlayer(gentity_t *pusher, gentity_t *victim) 
+{
+	vec3_t	dir, push;
+	int force;
+	float dist;
+
+	if(!g_shove.integer) return qfalse;
+
+	VectorSubtract(pusher->r.currentOrigin, victim->r.currentOrigin, dir);
+	dir[2] = 0;
+	dist = VectorNormalize(dir);
+	/*
+	dir[2] = 0;
+	VectorNormalizeFast(dir);
+	*/
+
+	if(dist > 50) return qfalse;
+
+	force = g_shove.integer;
+
+	/*
+	VectorScale(dir, force, push);
+
+	VectorAdd(pusher->s.pos.trDelta, push, pusher->s.pos.trDelta);
+	VectorAdd(pusher->client->ps.velocity, push, pusher->client->ps.velocity);
+	*/
+	VectorScale(dir, -force, push);
+	/*
+	// add a little hop, if not pushing up
+	if(push[2] >= 0)
+		push[2] = force/2;
+	*/
+
+	VectorAdd(victim->s.pos.trDelta, push, victim->s.pos.trDelta);
+	VectorAdd(victim->client->ps.velocity, push, victim->client->ps.velocity);
+
+	return qtrue;
+}
+
+
+/* 
+ G_DragCorpse //tjw
+ */
+qboolean G_DragCorpse(gentity_t *dragger, gentity_t *corpse) 
+{
+	vec3_t	dir, pull, res;
+	float dist;
+
+	if(!g_dragCorpse.integer) return qfalse;
+	VectorSubtract(dragger->r.currentOrigin, corpse->r.currentOrigin, dir);
+	dir[2] = 0;
+	dist = VectorNormalize(dir);
+
+	// don't pull corpses past the dragger's head and don't start dragging
+	// until both players look like they're in contact
+	if(dist > 85 || dist < 40) return qfalse;
+
+	VectorScale(dir, 100, pull);
+
+	// prevent some zipping around when the corpse doesn't have 
+	// much friction
+	VectorSubtract(pull, corpse->client->ps.velocity, res);
+
+	// no dragging into the ground
+	res[2] = 0;
+
+	VectorAdd(corpse->s.pos.trDelta, res, corpse->s.pos.trDelta );
+	VectorAdd(corpse->client->ps.velocity, res, corpse->client->ps.velocity);
+
+	return qtrue; // no checks yet
 }
 
 // TAT 1/14/2003 - extracted out the functionality of Cmd_Activate_f from finding the object to use
@@ -2744,45 +3304,87 @@
 	}
 }
 
-
+/*
+Cmd_Activate2_f() is only for:
+    uniform stealing
+	shove 
+	dragging
+	class switch
+ */
 void Cmd_Activate2_f( gentity_t *ent ) {
 	trace_t		tr;
 	vec3_t		end;
 	gentity_t	*traceEnt;
 	vec3_t		forward, right, up, offset;
-//	int			activatetime = level.time;
 	qboolean	found = qfalse;
 	qboolean	pass2 = qfalse;
 
-	if( ent->client->sess.playerType != PC_COVERTOPS ) {
-		return;
-	}
+
+	//if( ent->client->sess.playerType != PC_COVERTOPS ) {
+	//	return;
+	//}
 
 	AngleVectors (ent->client->ps.viewangles, forward, right, up);
 	CalcMuzzlePointForActivate (ent, forward, right, up, offset);
 	VectorMA (offset, 96, forward, end);
 
-	trap_Trace (&tr, offset, NULL, NULL, end, ent->s.number, (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE));
 
-	if ( tr.surfaceFlags & SURF_NOIMPACT || tr.entityNum == ENTITYNUM_WORLD) {
-		trap_Trace (&tr, offset, NULL, NULL, end, ent->s.number, (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE|CONTENTS_TRIGGER));
-		pass2 = qtrue;
-	}
-
-tryagain:
 
-	if ( tr.surfaceFlags & SURF_NOIMPACT || tr.entityNum == ENTITYNUM_WORLD) {
-		return;
+	// look for a corpse to drag
+	trap_Trace(&tr, 
+		offset, 
+		NULL, 
+		NULL, 
+		end, 
+		ent->s.number, 
+		CONTENTS_CORPSE);
+	if(tr.entityNum >= 0) {
+		traceEnt = &g_entities[tr.entityNum];
+		if(traceEnt->client) {
+			G_DragCorpse(ent, traceEnt);
+			return;
+		}
 	}
 
-	traceEnt = &g_entities[ tr.entityNum ];
-
-	found = Do_Activate2_f(ent, traceEnt);
+	// look for a guy to push
+	trap_Trace(&tr, 
+		offset, 
+		NULL, 
+		NULL, 
+		end, 
+		ent->s.number, 
+		CONTENTS_BODY);
+	if(tr.entityNum >= 0) {
+		traceEnt = &g_entities[tr.entityNum];
+		if(traceEnt->client) {
+			if(traceEnt->client->ps.eFlags & EF_PLAYDEAD) 
+				G_DragCorpse(ent, traceEnt);
+			else
+				G_PushPlayer(ent, traceEnt);
+			return;
+		}
+	}
 
-	if(!found && !pass2) {
-		pass2 = qtrue;
-		trap_Trace (&tr, offset, NULL, NULL, end, ent->s.number, (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE|CONTENTS_TRIGGER));
-		goto tryagain;
+	// look for a gibbed corpse
+	trap_Trace(&tr,
+		offset,
+		NULL,
+		NULL,
+		end,
+		ent->s.number,
+		(CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE));
+	if(tr.entityNum >= 0) {
+		traceEnt = &g_entities[tr.entityNum];
+		if(traceEnt->s.eType == ET_CORPSE && BODY_TEAM(traceEnt)) {
+				if(BODY_TEAM(traceEnt) == ent->client->sess.sessionTeam ) {
+					G_ClassSteal(ent, traceEnt);
+					return;
+				}
+				else if(ent->client->sess.playerType == PC_COVERTOPS)  {
+					G_UniformSteal(ent, traceEnt);
+					return;
+				}
+		}
 	}
 }
 
@@ -3282,7 +3884,7 @@
 	client->sess.playerWeapon = ent->client->sess.latchPlayerWeapon = cl.sess.playerWeapon;
 	client->sess.playerWeapon2 = ent->client->sess.latchPlayerWeapon2 = cl.sess.playerWeapon2;
 	// spawn them in
-	ClientSpawn(ent, qtrue);
+	ClientSpawn(ent, qtrue, qfalse, qtrue);
 	// restore items
 	client->pers = saved;
 	memcpy( ent->client->ps.persistant, persistant, sizeof(persistant) );
@@ -3316,6 +3918,11 @@
 			Cmd_Say_f (ent, SAY_ALL, qfalse);
 		}
 		return;
+	} 
+	
+	if (!Q_stricmp (cmd, "m")) {
+		G_PrivateMessage(ent);
+		return;
 	}
 
 	if( Q_stricmp (cmd, "say_team") == 0 ) {
@@ -3397,7 +4004,7 @@
 			return;
 		}
 
-		if( ent->client->ps.stats[STAT_HEALTH] <= 0 && ( ent->client->sess.sessionTeam == TEAM_AXIS || ent->client->sess.sessionTeam == TEAM_ALLIES ) ) {
+		if( ent->health <= 0 && ( ent->client->sess.sessionTeam == TEAM_AXIS || ent->client->sess.sessionTeam == TEAM_ALLIES ) ) {
 			limbo( ent, qtrue );
 		}
 
@@ -3426,6 +4033,10 @@
 	if(G_commandCheck(ent, cmd, qtrue)) return;
 	// OSP
 
+	if(G_shrubbot_permission(ent, SBF_STEALTH)) 
+		if(G_shrubbot_cmd_check(ent)) 
+			return;
+
 	// ignore all other commands when at intermission
 	if (level.intermissiontime) {
 //		Cmd_Say_f (ent, qfalse, qtrue);			// NERVE - SMF - we don't want to spam the clients with this.
@@ -3474,10 +4085,168 @@
 	// OSP
 	} else if(G_commandCheck(ent, cmd, qfalse)) {
 		return;
-
-	} else {
+	}
+	else if (!Q_stricmp (cmd, "playdead")) {
+		G_PlayDead(ent);
+	}
+	else {
 		trap_SendServerCommand( clientNum, va("print \"unknown cmd[lof] %s\n\"", cmd ) );
 	}
 }
 
 
+/*
+==================
+ConcatArgs
+==================
+*/
+char	*ConcatArgs( int start ) {
+	int		i, c, tlen;
+	static char	line[MAX_STRING_CHARS];
+	int		len;
+	char	arg[MAX_STRING_CHARS];
+
+	len = 0;
+	c = trap_Argc();
+	for ( i = start ; i < c ; i++ ) {
+		trap_Argv( i, arg, sizeof( arg ) );
+		tlen = strlen( arg );
+		if ( len + tlen >= MAX_STRING_CHARS - 1 ) {
+			break;
+		}
+		memcpy( line + len, arg, tlen );
+		len += tlen;
+		if ( i != c - 1 ) {
+			line[len] = ' ';
+			len++;
+		}
+	}
+
+	line[len] = 0;
+
+	return line;
+}
+
+
+char *Q_SayConcatArgs(int start) {
+	char *s;
+	int c = 0;
+
+	s = ConcatArgs(0);
+	while(*s) {
+		if(c == start) return s;
+		if(*s == ' ') {
+			*s++;
+			if(*s != ' ') {
+				c++;
+				continue;
+			}
+			while(*s && *s == ' ') *s++;  
+			c++;
+		}
+		*s++;
+	}
+	return s;
+}
+
+
+// replaces all occurances of "\n" with '\n'
+char *Q_AddCR(char *s)
+{
+	char *copy, *place, *start;
+
+	if(!*s) return s;
+	start = s;
+	while(*s) {
+		if(*s == '\\') {
+			copy = s;
+			place = s;
+			*s++;
+			if(*s && *s == 'n') {
+				*copy = '\n';
+				while(*++s) {
+					*++copy = *s;
+				}
+				*++copy = '\0';
+				s = place;
+				continue;
+			}
+		}
+		*s++;
+	}
+	return start;
+}
+
+// A replacement for trap_Argc() that can correctly handle
+//   say "!cmd arg0 arg1"
+// as well as
+//   say !cmd arg0 arg1
+// The client uses the latter for messages typed in the console
+// and the former when the message is typed in the chat popup
+int Q_SayArgc() 
+{
+	int c = 1;
+	char *s;
+
+	s = ConcatArgs(0);
+	if(!*s) return 0;
+	while(*s) {
+		if(*s == ' ') {
+			*s++;
+			if(*s != ' ') {
+				c++;
+				continue;
+			}
+			while(*s && *s == ' ') *s++;  
+			c++;
+		}
+		*s++;
+	}
+	return c;
+}
+
+// A replacement for trap_Argv() that can correctly handle
+//   say "!cmd arg0 arg1"
+// as well as
+//   say !cmd arg0 arg1
+// The client uses the latter for messages typed in the console
+// and the former when the message is typed in the chat popup
+qboolean Q_SayArgv(int n, char *buffer, int bufferLength)
+{
+	int bc = 1;
+	int c = 0;
+	char *s;
+
+	if(bufferLength < 1) return qfalse;
+	if(n < 0) return qfalse;
+	*buffer = '\0';
+	s = ConcatArgs(0);
+	while(*s) {
+		if(c == n) {
+			while(*s && (bc < bufferLength)) {
+				if(*s == ' ') {
+					*buffer = '\0';
+					return qtrue;
+				}
+				*buffer = *s;
+				*buffer++;
+				*s++;
+				bc++;
+			}
+			*buffer = '\0';
+			return qtrue;
+		}
+		if(*s == ' ') {
+			*s++;
+			if(*s != ' ') {
+				c++;
+				continue;
+			}
+			while(*s && *s == ' ') *s++;  
+			c++;
+		}
+		*s++;
+	}
+	return qfalse;
+}
+
diff -urN --exclude=.svn et.orig/src/game/g_combat.c etpub/src/game/g_combat.c
--- et.orig/src/game/g_combat.c	2003-07-22 17:05:56.000000000 -0500
+++ etpub/src/game/g_combat.c	2005-03-17 19:46:37.000000000 -0600
@@ -349,6 +349,7 @@
 	//float			timeLived;
 	weapon_t	weap = BG_WeaponForMOD( meansOfDeath );
 
+
 //	G_Printf( "player_die\n" );
 
 	if(attacker == self) {
@@ -435,9 +436,14 @@
 		killedintank = qtrue;
 	}
 
-	if( self->client->ps.pm_type == PM_DEAD || g_gamestate.integer == GS_INTERMISSION ) {
+	if((self->client->ps.pm_type == PM_DEAD  && 
+		!(self->client->ps.eFlags & EF_PLAYDEAD)) || 
+		g_gamestate.integer == GS_INTERMISSION ) {
 		return;
 	}
+	
+	// the player really died this time
+	self->client->ps.eFlags &= ~EF_PLAYDEAD;
 
 	// OSP - death stats handled out-of-band of G_Damage for external calls
 	G_addStats(self, attacker, damage, meansOfDeath);
@@ -507,7 +513,10 @@
 		if ( attacker == self || OnSameTeam (self, attacker ) ) {
 
 			// DHM - Nerve :: Complaint lodging
-			if( attacker != self && level.warmupTime <= 0 && g_gamestate.integer == GS_PLAYING) {
+			if(attacker != self && 
+				level.warmupTime <= 0 && 
+				g_gamestate.integer == GS_PLAYING &&
+				!G_shrubbot_permission(attacker, SBF_IMMUNITY)) {
 				if( attacker->client->pers.localClient ) {
 					trap_SendServerCommand( self-g_entities, "complaint -4" );
 				} else {
@@ -558,32 +567,7 @@
 	// Add team bonuses
 	Team_FragBonuses(self, inflictor, attacker);
 
-	// drop flag regardless
-	if (self->client->ps.powerups[PW_REDFLAG]) {
-		item = BG_FindItem("Red Flag");
-		if (!item)
-			item = BG_FindItem("Objective");
-
-		self->client->ps.powerups[PW_REDFLAG] = 0;
-	}
-	if (self->client->ps.powerups[PW_BLUEFLAG]) {
-		item = BG_FindItem("Blue Flag");
-		if (!item)
-			item = BG_FindItem("Objective");
-
-		self->client->ps.powerups[PW_BLUEFLAG] = 0;
-	}
-
-	if (item) {
-		vec3_t launchvel = { 0, 0, 0 };
-		gentity_t *flag = LaunchItem(item, self->r.currentOrigin, launchvel, self->s.number);
-
-		flag->s.modelindex2 = self->s.otherEntityNum2;// JPW NERVE FIXME set player->otherentitynum2 with old modelindex2 from flag and restore here
-		flag->message = self->message;	// DHM - Nerve :: also restore item name
-		// Clear out player's temp copies
-		self->s.otherEntityNum2 = 0;
-		self->message = NULL;
-	}
+	G_DropItems(self);
 
 	// send a fancy "MEDIC!" scream.  Sissies, ain' they?
 	if (self->client != NULL) {
@@ -622,8 +606,12 @@
 	//VectorCopy( self->s.angles, self->client->ps.viewangles );
 
 //	trap_UnlinkEntity( self );
-	self->r.maxs[2] = self->client->ps.crouchMaxZ;	//%	0;			// ydnar: so bodies don't clip into world
-	self->client->ps.maxs[2] = self->client->ps.crouchMaxZ;	//%	0;	// ydnar: so bodies don't clip into world
+
+	// ydnar: so bodies don't clip into world
+	self->r.maxs[2] = self->client->ps.crouchMaxZ;	
+	self->client->ps.maxs[2] = self->client->ps.crouchMaxZ;	
+
+
 	trap_LinkEntity( self );
 
 	// don't allow respawn until the death anim is done
@@ -753,7 +741,10 @@
 
 		G_SetOrigin (head, ent->r.currentOrigin); 
 
-		if( ent->client->ps.eFlags & EF_PRONE ) {
+		if( (ent->client->ps.eFlags & EF_PRONE) ||
+			(ent->client->ps.eFlags & EF_DEAD) ||
+			(ent->client->ps.eFlags & EF_PLAYDEAD)) {
+
 			height = ent->client->ps.viewheight - 56;
 		} else if( ent->client->ps.pm_flags & PMF_DUCKED ) {	// closer fake offset for 'head' box when crouching
 			height = ent->client->ps.crouchViewHeight - 12;
@@ -773,13 +764,31 @@
 		AngleVectors( angles, forward, right, up );
 		if( ent->client->ps.eFlags & EF_PRONE ) {
 			VectorScale( forward, 24, v );
-		} else {
+		}
+		else if((ent->client->ps.eFlags & EF_DEAD) ||
+			(ent->client->ps.eFlags & EF_PLAYDEAD)) {
+			VectorScale( forward, -24, v );
+		}
+		else {
 			VectorScale( forward, 5, v );
 		}
 		VectorMA( v, 18, up, v );
 
 		VectorAdd( v, head->r.currentOrigin, head->r.currentOrigin );
 		head->r.currentOrigin[2] += height / 2;
+		
+		// tjw: the player entity's origin in the tank
+		//      is too low.  I compensate for this with
+		//      my hitbox hack in g_weapon.c by not 
+		//      artificially lowering the maxs if the
+		//      player is in the tank.  However, the
+		//      head also needs to be moved up.
+		//      
+		//      Will this break hitboxes in other movers?
+		//      "Only time... will tell."
+		if((ent->client->ps.eFlags & EF_MOUNTEDTANK))
+			head->r.currentOrigin[2] += 12;
+
 		// -NERVE - SMF
 	}
 
@@ -804,7 +813,9 @@
 	vec3_t flatforward, org;
 	//orientation_t or;			// DHM - Nerve
 
-	if( !(ent->client->ps.eFlags & EF_PRONE) )
+	if( !(ent->client->ps.eFlags & EF_PRONE) &&
+		!(ent->client->ps.eFlags & EF_DEAD) &&
+		!(ent->client->ps.eFlags & EF_PLAYDEAD))
 		return NULL;
 
 	leg = G_Spawn ();
@@ -812,9 +823,14 @@
 	AngleVectors( ent->client->ps.viewangles, flatforward, NULL, NULL );
 	flatforward[2] = 0;
 	VectorNormalizeFast( flatforward );
-
-	org[0] = ent->r.currentOrigin[0] + flatforward[0] * -32;
-	org[1] = ent->r.currentOrigin[1] + flatforward[1] * -32;
+	if(ent->client->ps.eFlags & EF_PRONE) {
+		org[0] = ent->r.currentOrigin[0] + flatforward[0] * -32;
+		org[1] = ent->r.currentOrigin[1] + flatforward[1] * -32;
+	}
+	else {
+		org[0] = ent->r.currentOrigin[0] + flatforward[0] * 32;
+		org[1] = ent->r.currentOrigin[1] + flatforward[1] * 32;
+	}
 	org[2] = ent->r.currentOrigin[2] + ent->client->pmext.proneLegsOffset;
 
 	G_SetOrigin( leg, org );
@@ -835,7 +851,7 @@
 	return leg;
 }
 
-qboolean IsHeadShot( gentity_t *targ, vec3_t dir, vec3_t point, int mod ) {
+qboolean IsHeadShot( gentity_t *attacker, gentity_t *targ, vec3_t dir, vec3_t point, int mod ) {
 	gentity_t	*head;
 	trace_t		tr;
 	vec3_t		start, end;
@@ -845,8 +861,8 @@
 	if( !(targ->client) )
 		return qfalse;
 
-	if( targ->health <= 0 )
-		return qfalse;
+	//if( targ->health <= 0 )
+	//	return qfalse;
 
 	if (!IsHeadShotWeapon (mod) ) {
 		return qfalse;
@@ -857,7 +873,14 @@
 	// trace another shot see if we hit the head
 	VectorCopy( point, start );
 	VectorMA( start, 64, dir, end );
-	trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+	// josh: Backwards reconcile the head. OUCH!
+	if (g_antilag.integer) {
+		G_AdjustSingleClientPosition(targ,attacker->client->pers.cmd.serverTime);
+		trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+		G_ReAdjustSingleClientPosition(targ);
+	} else {
+		trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+	}
 		
 	traceEnt = &g_entities[ tr.entityNum ];
 
@@ -893,7 +916,7 @@
 	return qfalse;
 }
 
-qboolean IsLegShot( gentity_t *targ, vec3_t dir, vec3_t point, int mod ) {
+qboolean IsLegShot( gentity_t *attacker, gentity_t *targ, vec3_t dir, vec3_t point, int mod ) {
 	float height;
 	float theight;
 	gentity_t *leg;
@@ -901,8 +924,8 @@
 	if (!(targ->client))
 		return qfalse;
 
-	if (targ->health <= 0)
-		return qfalse;
+	//if (targ->health <= 0)
+	//	return qfalse;
 
 	if(!point) {
 		return qfalse;
@@ -922,7 +945,14 @@
 		// trace another shot see if we hit the legs
 		VectorCopy( point, start );
 		VectorMA( start, 64, dir, end );
-		trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+		// josh: Backwards reconcile the legs. Whoah! Where'd dey go?
+		if (g_antilag.integer) {
+			G_AdjustSingleClientPosition(targ,attacker->client->pers.cmd.serverTime);
+			trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+			G_ReAdjustSingleClientPosition(targ);
+		} else {
+			trap_Trace( &tr, start, NULL, NULL, end, targ->s.number, MASK_SHOT );
+		}
 			
 		traceEnt = &g_entities[ tr.entityNum ];
 
@@ -1024,6 +1054,7 @@
 	int			take;
 	int			save;
 	int			knockback;
+	int			limbo_health;
 	qboolean	headShot;
 	qboolean	wasAlive;
 	hitRegion_t	hr = HR_NUM_HITREGIONS;
@@ -1061,6 +1092,10 @@
 	// xkan, 12/23/2002 - was the bot alive before applying any damage?
 	wasAlive = (targ->health > 0);
 
+
+	limbo_health = FORCE_LIMBO_HEALTH;
+	if(g_forceLimboHealth.integer == 1) limbo_health = -150;
+
 	// Arnout: combatstate
 	if( targ->client && attacker && attacker->client && attacker != targ ) {
 		/*vec_t dist = -1.f;
@@ -1348,15 +1383,6 @@
 		}
 	}
 
-	// add to the attacker's hit counter
-	if ( attacker->client && targ != attacker && targ->health > 0 ) {
-		if ( OnSameTeam( targ, attacker ) ) {
-			attacker->client->ps.persistant[PERS_HITS] -= damage;
-		} else {
-			attacker->client->ps.persistant[PERS_HITS] += damage;
-		}
-	}
-
 	if ( damage < 1 ) {
 		damage = 1;
 	}
@@ -1369,7 +1395,10 @@
 	}
 
 	// save some from flak jacket
-	if( targ->client && targ->client->sess.skill[SK_EXPLOSIVES_AND_CONSTRUCTION] >= 4 && targ->client->sess.playerType == PC_ENGINEER ) {
+	if( targ->client 
+	    && targ->client->sess.skill[SK_EXPLOSIVES_AND_CONSTRUCTION] >= 4
+	    && (targ->client->sess.playerType == PC_ENGINEER 
+	      || (g_skills.integer & SKILLS_FLAK))) {
 		if( mod == MOD_GRENADE ||
 			mod == MOD_GRENADE_LAUNCHER ||
 			mod == MOD_ROCKET ||
@@ -1391,7 +1420,7 @@
 		}
 	}
 
-	headShot = IsHeadShot(targ, dir, point, mod);
+	headShot = IsHeadShot(attacker, targ, dir, point, mod);
 	if ( headShot ) {
 		if( take * 2 < 50 ) // head shots, all weapons, do minimum 50 points damage
 			take = 50;
@@ -1425,7 +1454,8 @@
 			}
 		}
 
-		targ->client->ps.eFlags |= EF_HEADSHOT;
+		// moved this to below hitsounds so it can still be checked
+		//targ->client->ps.eFlags |= EF_HEADSHOT; 
 
 		// OSP - Record the headshot
 		if(client && attacker && attacker->client
@@ -1441,7 +1471,7 @@
 		}
 		G_LogRegionHit( attacker, HR_HEAD );
 		hr = HR_HEAD;
-	} else if ( IsLegShot(targ, dir, point, mod) ) {
+	} else if ( IsLegShot(attacker, targ, dir, point, mod) ) {
 		G_LogRegionHit( attacker, HR_LEGS );
 		hr = HR_LEGS;
 		if( g_debugBullets.integer ) {
@@ -1491,6 +1521,70 @@
 
 	// See if it's the player hurting the emeny flag carrier
 //	Team_CheckHurtCarrier(targ, attacker);
+	
+
+	// add to the attacker's hit counter
+	if ( attacker->client && 
+			targ->client &&
+			targ != attacker &&
+			targ->health > limbo_health ) {
+		
+		if ( OnSameTeam( targ, attacker ) ) {
+			attacker->client->ps.persistant[PERS_HITS] -= damage;
+		} else {
+			attacker->client->ps.persistant[PERS_HITS] += damage;
+		}
+				
+		// tjw - hitsounds for a server side only mod
+		if(g_hitsounds.integer && attacker->client->pers.hitsounds) {
+
+			gentity_t *hs_ent;
+			int snd;
+
+			hs_ent = G_TempEntity(attacker->client->ps.origin, 
+				       EV_GLOBAL_CLIENT_SOUND);
+			hs_ent->s.teamNum = (attacker->client - level.clients);
+
+			// default hitsound
+			snd = G_SoundIndex(g_hitsound_default.string);
+
+			// vsay "hold your fire" on the first hit of a teammate
+			// only applies if the player has been hurt before
+			// and the match is not in warmup.
+			if(OnSameTeam(targ, attacker)) {
+				if((!client->lasthurt_mod || 
+					client->lasthurt_client != attacker->s.number) &&
+					g_gamestate.integer == GS_PLAYING &&
+					(targ->health - take) > limbo_health) {
+					
+					if(client->sess.sessionTeam == TEAM_AXIS)
+						snd = G_SoundIndex(g_hitsound_team_warn_axis.string);
+					else	
+						snd = G_SoundIndex(g_hitsound_team_warn_allies.string);
+				}
+				else if(headShot) {
+					if(!(targ->client->ps.eFlags & EF_HEADSHOT))
+						snd = G_SoundIndex(g_hitsound_team_helmet.string);
+					else 
+						snd = G_SoundIndex(g_hitsound_team_head.string);
+				}
+				else {
+					snd = G_SoundIndex(g_hitsound_team_default.string);
+				}
+			}
+			else if(headShot) {
+				if(!(targ->client->ps.eFlags & EF_HEADSHOT))
+					snd = G_SoundIndex(g_hitsound_helmet.string);
+				else 
+					snd = G_SoundIndex(g_hitsound_head.string);
+			}
+			hs_ent->s.eventParm = snd;
+		}
+	}
+
+	// remember that this player has no helmet
+	if(headShot) targ->client->ps.eFlags |= EF_HEADSHOT; 
+
 
 	if (targ->client) {
 		// s