#include "precompiled.h"
#pragma hdrstop

#include "prey_local.h"

#define DAMAGE_INDICATOR_TIME		1100		// Update this in hud_damageindicator.guifragment too

const idEventDef EV_PlayWeaponAnim( "playWeaponAnim", "sd" );
const idEventDef EV_RechargeHealth( "<rechargehealth>", NULL );
const idEventDef EV_RechargeRifleAmmo( "<rechargeRifleAmmo>", NULL );
const idEventDef EV_Cinematic( "cinematic", "dd" );
const idEventDef EV_DialogStart( "dialogStart", "ddd" );
const idEventDef EV_DialogStop( "dialogStop", NULL );
const idEventDef EV_LotaTunnelMode( "lotaTunnelMode", "d" );
const idEventDef EV_DrainSpiritPower( "<drainspiritpower>", NULL );
const idEventDef EV_SpawnDeathWraith( "<spawndeathwraith>", NULL );
const idEventDef EV_PrepareToResurrect( "prepareToResurrect" );
const idEventDef EV_ResurrectScreenFade( "<resurrectScreenFade>" );
const idEventDef EV_Resurrect( "resurrect" );
const idEventDef EV_PrepareForDeathWorld( "<prepareForDeathWorld>", NULL );
const idEventDef EV_EnterDeathWorld( "<enterDeathWorld>", NULL );
const idEventDef EV_AdjustSpiritPowerDeathWalk( "<adjustSpiritPowerDeathWalk>" );
const idEventDef EV_SetOverlayMaterial( "setOverlayMaterial", "sd" );
const idEventDef EV_SetOverlayTime( "setOverlayTime", "fd" );
const idEventDef EV_SetOverlayColor( "setOverlayColor", "ffff" );
const idEventDef EV_DDAHeartbeat( "<ddaHeartBeat>", NULL );
const idEventDef EV_ShouldRemainAlignedToAxial( "shouldRemainAlignedToAxial", "d" );
const idEventDef EV_StartHudTranslation( "<starthudtranslation>" );
const idEventDef EV_Unfreeze( "<unfreeze>" );
const idEventDef EV_GetSpiritPower( "getSpiritPower", "", 'f' ); //rww
const idEventDef EV_SetSpiritPower( "setSpiritPower", "f" ); //rww
const idEventDef EV_OnGround( "onGround", NULL, 'f' ); // bg
const idEventDef EV_BindUnfroze( "<bindUnfroze>", "e" ); // mdl
const idEventDef EV_LockWeapon( "lockWeapon", "d" ); // mdl
const idEventDef EV_UnlockWeapon( "unlockWeapon", "d" ); // mdl
const idEventDef EV_SetPrivateCameraView( "setPrivateCameraView", "Ed" ); //rdr
const idEventDef EV_SetCinematicFOV( "setCinematicFOV", "ffff" ); //rdr
const idEventDef EV_StopSpiritWalk( "stopSpiritWalk" ); //rww
const idEventDef EV_DamagePlayer( "damagePlayer", "eevsfd" ); //rww
const idEventDef EV_GetSpiritProxy( "getSpiritProxy", "", 'e' ); //jsh
const idEventDef EV_IsSpiritWalking( "isSpiritWalking", "", 'd' ); // pdm
const idEventDef EV_IsDeathWalking( "isDeathWalking", "", 'd' ); // bjk
const idEventDef EV_GetDDAValue( "getDDAValue", "", 'f' ); // cjr
const idEventDef EV_AllowLighter( "allowLighter", "d" ); // jsh
const idEventDef EV_DisableSpirit( "disableSpirit" ); // mdl
const idEventDef EV_EnableSpirit( "enableSpirit" ); // mdl
const idEventDef EV_UpdateDDA( "<updateDDA>" ); // cjr
const idEventDef EV_AllowDamage( "<allowDamage>" ); // mdl
const idEventDef EV_IgnoreDamage( "<ignoreDamage>" ); // mdl
const idEventDef EV_RespawnCleanup( "<respawncleanup>" ); //rww
const idEventDef EV_ReturnToWeapon( "returnToWeapon", "", 'd' ); //bjk
const idEventDef EV_CanAnimateTorso( "canAnimateTorso", "", 'd' ); //rww

CLASS_DECLARATION( idPlayer, hhPlayer )
	EVENT( EV_PlayWeaponAnim,				hhPlayer::Event_PlayWeaponAnim )
	EVENT( EV_RechargeHealth,				hhPlayer::Event_RechargeHealth )
	EVENT( EV_RechargeRifleAmmo,			hhPlayer::Event_RechargeRifleAmmo )
	EVENT( EV_Cinematic,					hhPlayer::Event_Cinematic )
	EVENT( EV_DialogStart,					hhPlayer::Event_DialogStart )
	EVENT( EV_DialogStop,					hhPlayer::Event_DialogStop )
	EVENT( EV_LotaTunnelMode,				hhPlayer::Event_LotaTunnelMode )
	EVENT( EV_DrainSpiritPower,				hhPlayer::Event_DrainSpiritPower )
	EVENT( EV_SpawnDeathWraith,				hhPlayer::Event_SpawnDeathWraith )
	EVENT( EV_PrepareToResurrect,			hhPlayer::Event_PrepareToResurrect )
	EVENT( EV_ResurrectScreenFade,			hhPlayer::Event_ResurrectScreenFade )
	EVENT( EV_Resurrect,					hhPlayer::Event_Resurrect )
	EVENT( EV_EnterDeathWorld,				hhPlayer::Event_EnterDeathWorld )
	EVENT( EV_PrepareForDeathWorld,			hhPlayer::Event_PrepareForDeathWorld )
	EVENT( EV_AdjustSpiritPowerDeathWalk,	hhPlayer::Event_AdjustSpiritPowerDeathWalk )
	EVENT( EV_ShouldRemainAlignedToAxial,	hhPlayer::Event_ShouldRemainAlignedToAxial )
	EVENT( EV_OrientToGravity,				hhPlayer::Event_OrientToGravity )
	EVENT( EV_ResetGravity,					hhPlayer::Event_ResetGravity )
	EVENT( EV_SetOverlayMaterial,			hhPlayer::Event_SetOverlayMaterial )
	EVENT( EV_SetOverlayTime,				hhPlayer::Event_SetOverlayTime )
	EVENT( EV_SetOverlayColor,				hhPlayer::Event_SetOverlayColor )
	EVENT( EV_DDAHeartbeat,					hhPlayer::Event_DDAHeartBeat )
	EVENT( EV_StartHudTranslation,			hhPlayer::Event_StartHUDTranslation)
	EVENT( EV_Unfreeze,						hhPlayer::Event_Unfreeze)
	EVENT( EV_GetSpiritPower,				hhPlayer::Event_GetSpiritPower) //rww
	EVENT( EV_SetSpiritPower,				hhPlayer::Event_SetSpiritPower) //rww
	EVENT( EV_OnGround,						hhPlayer::Event_OnGround ) // bg
	EVENT( EV_LockWeapon,					hhPlayer::Event_LockWeapon ) // mdl
	EVENT( EV_UnlockWeapon,					hhPlayer::Event_UnlockWeapon ) // mdl
	EVENT( EV_SetPrivateCameraView,			hhPlayer::Event_SetPrivateCameraView ) //rdr
	EVENT( EV_SetCinematicFOV,				hhPlayer::Event_SetCinematicFOV ) //rdr
	EVENT( EV_StopSpiritWalk,				hhPlayer::Event_StopSpiritWalk ) //rww
	EVENT( EV_DamagePlayer,					hhPlayer::Event_DamagePlayer ) //rww
	EVENT( EV_GetSpiritProxy,				hhPlayer::Event_GetSpiritProxy ) //rww
	EVENT( EV_IsSpiritWalking,				hhPlayer::Event_IsSpiritWalking ) //pdm
	EVENT( EV_IsDeathWalking,				hhPlayer::Event_IsDeathWalking ) //bjk
	EVENT( EV_GetDDAValue,					hhPlayer::Event_GetDDAValue ) // cjr
	EVENT( EV_AllowLighter,					hhPlayer::Event_AllowLighter ) // jsh
	EVENT( EV_DisableSpirit,				hhPlayer::Event_DisableSpirit ) // mdl
	EVENT( EV_EnableSpirit,					hhPlayer::Event_EnableSpirit ) // mdl
	EVENT( EV_UpdateDDA,					hhPlayer::Event_UpdateDDA ) // cjr
	EVENT( EV_AllowDamage,					hhPlayer::Event_AllowDamage ) // mdl
	EVENT( EV_IgnoreDamage,					hhPlayer::Event_IgnoreDamage ) // mdl
	EVENT( EV_RespawnCleanup,				hhPlayer::Event_RespawnCleanup ) //rww
	EVENT( EV_ReturnToWeapon,				hhPlayer::Event_ReturnToWeapon ) //bjk
	EVENT( EV_CanAnimateTorso,				hhPlayer::Event_CanAnimateTorso ) //rww
END_CLASS

//rww
CLASS_DECLARATION( hhPlayer, hhArtificialPlayer )
END_CLASS

/*
=================
hhPlayer::hhPlayer
=================
*/
hhPlayer::hhPlayer( void ) :
	thirdPersonCameraClipBounds( idTraceModel(idBounds(idVec3(-4, -8, -8), idVec3(8, 8, 8))) ) {

	hand				= NULL;	// nla
	spiritProxy			= NULL;
	possessedTommy		= NULL;
	talon				= NULL;
	handNext			= NULL;
	deathLookAtEntity	= NULL;
	guiWantsControls	= NULL;
	lighterHandle		= -1;
	nextTalonAttackCommentTime = 0;
	bTalonAttackComment = false;
	bSpiritWalk			= false;
	bDeathWalk			= false;
	bReallyDead			= false;
	bPossessed			= false;
	bInCinematic		= false;
	bFrozen				= false;
	bScopeView			= false; //rww
	bInDeathwalkTransition = false;
	lastAppliedBobCycle = 0;
#if GAMEPAD_SUPPORT	// VENOM BEGIN
	lastAutoLevelTime	= 0;
	lastAccelTime		= 0;
	lastAccelFactor		= 1.0f;
#endif // VENOM END
	cinematicFOV.Init( gameLocal.time, 0.f, 0.f, 0.f, 90.f, 90.f ); //rdr
	mpHitFeedbackTime	= 0; //rww
	bAllowSpirit		= true; //mdl
	bCollidingWithPortal = false;
	bPlayingLowHealthSound = false;
	bLotaTunnelMode = false;

	for (int ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		lastAttackers[ix].attacker = NULL;
		lastAttackers[ix].time = 0;
		lastAttackers[ix].displayed = false;
	}

	forcePredictionButtons = 0; //rww
	//HUMANHEAD PCF mdl 05/02/06 - Initialize weaponFlags to prevent problems during spawn
	weaponFlags = -1;

	//HUMANHEAD PCF rww 05/03/06 - initialize bob to 0
	bob = 0.0f;
}

void hhPlayer::LinkScriptVariables( void ) {
	idPlayer::LinkScriptVariables();

	AI_ASIDE.LinkTo( scriptObject, "AI_ASIDE" );
}

/*
==============
hhPlayer::Spawn

Prepare any resources used by the player.
==============
*/
void hhPlayer::Spawn( void ) {

	SetupWeaponInfo();

	spiritDrainHeartbeatMS = SEC2MS(spawnArgs.GetFloat( "spiritDrainHeartbeat", "0.15" ));

	ddaHeartbeatMS = SEC2MS(spawnArgs.GetFloat( "dda_heartbeat", "1" ));
	ddaNumEnemies = 0;
	ddaProbabilityAccum = 1.0f;

	// Start DDA heartbeat events, only in single player
	if ( !gameLocal.isMultiplayer ) {
		PostEventMS( &EV_DDAHeartbeat, ddaHeartbeatMS );
	}

	//Setup crashland stuff
	float gravityMagnitude = physicsObj.GetGravity().Length();
	crashlandSpeed_fatal = hhUtils::DetermineFinalFallVelocityMagnitude( spawnArgs.GetFloat("fallDist_fatal"), gravityMagnitude );
	crashlandSpeed_soft = hhUtils::DetermineFinalFallVelocityMagnitude( spawnArgs.GetFloat("fallDist_soft"), gravityMagnitude );;
	crashlandSpeed_jump = hhUtils::DetermineFinalFallVelocityMagnitude( spawnArgs.GetFloat("fallDist_jump"), gravityMagnitude );;

	spiritwalkSoundController.SetLoopOnlyOnLocal(entityNumber); //rww
	spiritwalkSoundController.SetOwner( this );
	spiritwalkSoundController.SetLeadIn( spawnArgs.GetString("snd_spiritWalkActivate") );
	spiritwalkSoundController.SetLoop( spawnArgs.GetString("snd_spiritWalkIdle") );
	spiritwalkSoundController.SetLeadOut( spawnArgs.GetString("snd_spiritWalkDeactivate") );
	spiritwalkSoundController.bPlaying = false;

	deathwalkSoundController.SetOwner( this );
	deathwalkSoundController.SetLeadIn( spawnArgs.GetString("snd_deathWalkActivate") );
	deathwalkSoundController.SetLoop( spawnArgs.GetString("snd_deathWalkIdle") );
	deathwalkSoundController.SetLeadOut( spawnArgs.GetString("snd_deathWalkDeactivate") );
	deathwalkSoundController.bPlaying = false;

	wallwalkSoundController.SetOwner( this );
	wallwalkSoundController.SetLeadIn( spawnArgs.GetString("snd_wallwalkActivate") );
	wallwalkSoundController.SetLoop( spawnArgs.GetString("snd_wallwalkIdle") );
	wallwalkSoundController.SetLeadOut( spawnArgs.GetString("snd_wallwalkDeactivate") );
	wallwalkSoundController.bPlaying = false;

	lastResurrectTime	= 0;

	SetVehicleInterface( &vehicleInterfaceLocal );

	kickSpring = spawnArgs.GetFloat( "kickSpring" );	//HUMANHEAD bjk
	kickDamping = spawnArgs.GetFloat( "kickDamping" );	//HUMANHEAD bjk

	// mdl: Make sure the lighter is cleared
	memset( &lighter, 0, sizeof( lighter ) );

	SetupWeaponFlags();
	if ( idealWeapon < 1 || idealWeapon > 8 ) {
		// Go to the highest weapon available if no weapon is current selected (NOTE:  This will be ignored if all weapons are locked)
		NextBestWeapon();	//HUMANHEAD bjk
	} 

	//HUMANHEAD PCF mdl 04/26/06 - Made this a separate if block from above so we can disallow locked weapons
	if ( ! ( weaponFlags & ( 1 << ( idealWeapon - 1 ) ) ) ) {
		// If the current weapon is invalid now, try the next weapon
		NextWeapon();
		if ( ! ( weaponFlags & ( 1 << ( idealWeapon - 1 ) ) ) ) {
			// No weapons available
			if ( weapon.GetEntity() ) {
				weapon.GetEntity()->PutAway();
				weapon.GetEntity()->HideWeapon();
			}
			idealWeapon = 0;
			currentWeapon = -1;
		}
	}

	nextSpiritTime = 0;

	mpHitFeedbackTime = 0; //rww

	airAttackerTime = 0;
	bDeathWalkStage2 = false;

	physicsObj.SetInwardGravity(-1); //rww
}

void hhPlayer::RestorePersistantInfo( void ) {
	int num;

	idPlayer::RestorePersistantInfo();

	// Update persistent amoo maximums
	num = GetWeaponNum("weaponobj_soulstripper");
	assert(num);
	weaponInfo[ num ].ammoMax = spawnArgs.GetInt( "max_ammo_energy" );

	num = GetWeaponNum("weaponobj_bow");
	assert(num);
	weaponInfo[ num ].ammoMax = spawnArgs.GetInt( "max_ammo_spiritpower" );
}

/*
==============
hhPlayer::SpawnTalon()
==============
*/
void hhPlayer::TrySpawnTalon() {
	// TODO:  Deal with co-op issues.  Have multiple Talons in co-op, or just one?
	if (inventory.requirements.bCanSummonTalon && !talon.IsValid()) {
		talon = (hhTalon *)gameLocal.SpawnObject( spawnArgs.GetString( "def_hawkpower" ), NULL );
		if( talon.IsValid() ) {
			talon->SetOwner( this );
			talon->SummonTalon();
			bTalonAttackComment = true;
			nextTalonAttackCommentTime = 0;
		}
	}
}

/*
==============
hhPlayer::TalonAttackComment

Talon is attacking an enemy, so have Tommy make a comment
==============
*/
void hhPlayer::TalonAttackComment() {
	if ( IsDeathWalking() ) {
		return;
	}

	// Play a sound on the player to encourage Talon to attack
	if ( bTalonAttackComment && gameLocal.GetTime() > nextTalonAttackCommentTime ) { // Player can make an attack comment
		int num = spawnArgs.GetInt( "numAttackComments", "6" );

		StartSound( va( "snd_talonattack%d", gameLocal.random.RandomInt( num ) ), SND_CHANNEL_VOICE, 0, false, NULL );
		nextTalonAttackCommentTime = gameLocal.GetTime() + spawnArgs.GetInt( "talonAttackCommentTime", "30000" );
	}
}

/*
==============
hhPlayer::~hhPlayer()

Release any resources used by the player.
==============
*/
hhPlayer::~hhPlayer() {
	//rww - remove me if i'm a pilot
	if (InVehicle() && GetVehicleInterface() && GetVehicleInterface()->GetVehicle()) {
		GetVehicleInterface()->GetVehicle()->EjectPilot();
	}

	StopSpiritWalk();

	RemoveResources();
}


void hhPlayer::RemoveResources() {
	LighterOff();
	SAFE_REMOVE( hand );		//FIXME: Should this be something other than a safe remove?  (ie, remove hand?)
	SAFE_REMOVE( talon );
	SAFE_REMOVE( spiritProxy );
	SAFE_REMOVE( possessedTommy );
}


/*
==============
hhPlayer::Init()

Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
Called during SpawnToPoint
==============
*/
void hhPlayer::Init() {
	oldCmdAngles.Zero();

	idPlayer::Init();

	// initialize the script variables
	AI_ASIDE			= false;

	bInDeathwalkTransition = false;
	bShowProgressBar	= false;
	progressBarValue	= 0.0f;
	progressBarState	= 0;
	progressBarGuiValue.Init(gameLocal.time, 0, 0.0f, 0.0f);

	LighterOff(); //rww - make sure lighter is removed first (primarily for mp)

	bobFrac				= 0.0f;
	lighterTemperature	= 0;
	lighterHandle		= -1;
	bPossessed			= false;	// cjr - player is unpossessed at the start
	possessionTimer		= 0;		// cjr - player is unpossessed at the start
	possessionFOV		= 0;		// cjr - no FOV change for possession at start
	nextTalonAttackCommentTime = 0;
	bTalonAttackComment = false;	// cjr - If Tommy can make comments about talon attacking enemies
	bSpiritWalk			= false;	// cjr - initialize spiritwalk variables
	spiritProxy			= NULL;		// cjr - initialize spiritwalk variables
	possessedTommy		= NULL;		// cjr - initialize possessed tommy
	lastWeaponSpirit	= 0;		// cjr - initialize spiritwalk variables
	guiWantsControls	= NULL;		// pdm - gui that controls should be routed to
	bClampYaw			= false;	// pdm - whether do clamp yaw to master's axis (for rail rides)
	maxRelativeYaw		= 180.0f;	// pdm - max deviation from master axis allowed when clamping yaw
	maxRelativePitch	= 0.0f;		// rww - max deviation from master axis allowed when clamping pitch
	bInCinematic		= false;	// pdm - our simple cinematic system (position locking)
	lockView			= false;
	preCinematicWeapon	= 0;
	preCinematicWeaponFlags = 0;
	guiOverlay			= NULL;		// pdm - current overlay gui
	spiritWalkToggleTime = 0;
	bLotaTunnelMode			= false;

	StopSound(SND_CHANNEL_HEART, false); //rww - make sure this is stopped here, could conceivably still be playing on respawn
	bPlayingLowHealthSound = false;

	// Set shuttle view off
	if (entityNumber == gameLocal.localClientNum) { //rww
		renderSystem->SetShuttleView( false );
	}

	if (gameLocal.isMultiplayer) { //rww - reset my really-deadness when i respawn in MP
		bReallyDead = false;
		SetSkinByName(NULL); //make sure we are not using spiritwalk skin.
	}

	SetViewAnglesSensitivity(1.0f);
	cameraInterpolator.SetSelf( this );

	for (int ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		lastAttackers[ix].attacker = NULL;
		lastAttackers[ix].time = 0;
		lastAttackers[ix].displayed = false;
	}

	physicsObj.SetInwardGravity(-1); //rww
}

/*
===========
hhPlayer::SpawnToPoint

Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState

HUMANHEAD pdm: Many things are initialized in here as this is called before hhPlayer::Spawn. (from idPlayer::Spawn())
Most of it probably belongs in ::Init() for clarity.
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge (big chunk taken from idPlayer::SpawnToPoint)
============
*/
void hhPlayer::SpawnToPoint( const idVec3 &spawn_origin, const idAngles &spawn_angles ) {	

	RemoveResources();

	// HUMANHEAD aob
	SetAngles( spawn_angles );						// added because we might die while wallwalking
	SetUntransformedViewAngles( spawn_angles );		// Must be initialized before first think below
	SetUntransformedViewAxis( idAngles(0.0f, spawn_angles.yaw, 0.0f).ToMat3() );
	SetViewAnglesSensitivity( 1.0f );				// Must be initialized before first think below
	//HUMANHEAD END

	// idPlayer::SpawnToPoint() code ------------------------------
	idVec3 spec_origin;

	assert( !gameLocal.isClient );

	respawning = true;

	//HUMANHEAD rww - moved this up above call to Init, since things in there can query player's viewpos.
	kickSpring = spawnArgs.GetFloat( "kickSpring" );	//HUMANHEAD bjk
	kickDamping = spawnArgs.GetFloat( "kickDamping" );	//HUMANHEAD bjk

	Init();

	fl.noknockback = false;

	// stop any ragdolls being used
	StopRagdoll();

	// set back the player physics
	SetPhysics( &physicsObj );

	physicsObj.SetClipModelAxis();
	physicsObj.EnableClip();

	if ( !spectating ) {
		SetCombatContents( true );
	}

	physicsObj.SetLinearVelocity( vec3_origin );

	// setup our initial view
	if ( !spectating ) {
		SetOrigin( spawn_origin );
	} else {
		spec_origin = spawn_origin;
		spec_origin[ 2 ] += pm_normalheight.GetFloat();
		spec_origin[ 2 ] += SPECTATE_RAISE;
		SetOrigin( spec_origin );
	}

	// if this is the first spawn of the map, we don't have a usercmd yet,
	// so the delta angles won't be correct.  This will be fixed on the first think.
	viewAngles = ang_zero;
	SetDeltaViewAngles( ang_zero );
	SetViewAngles( spawn_angles );
	spawnAngles = spawn_angles;
	spawnAnglesSet = false;

	legsForward = true;
	legsYaw = 0.0f;
	idealLegsYaw = 0.0f;
	oldViewYaw = viewAngles.yaw;

	if ( spectating ) {
		Hide();
	} else {
		Show();
	}

	if ( gameLocal.isMultiplayer ) {
#ifndef HUMANHEAD //jsh We don't have a teleport effect
		if ( !spectating ) {
			// we may be called twice in a row in some situations. avoid a double fx and 'fly to the roof'
			if ( lastTeleFX < gameLocal.time - 1000 ) {
				idEntityFx::StartFx( spawnArgs.GetString( "fx_spawn" ), &spawn_origin, NULL, this, true );
				lastTeleFX = gameLocal.time;
			}
		}
#endif
		AI_TELEPORT = false;//true; //HUMANHEAD rww - we don't have a teleport anim either, ha ha ha (well we do, but it's not done)
	} else {
		AI_TELEPORT = false;
	}

	// kill anything at the new position
	if ( !spectating ) {
		physicsObj.SetClipMask( MASK_PLAYERSOLID ); // the clip mask is usually maintained in Move(), but KillBox requires it
		gameLocal.KillBox( this );
	}

	// don't allow full run speed for a bit
	physicsObj.SetKnockBack( 100 );

	// set our respawn time and buttons so that if we're killed we don't respawn immediately
	minRespawnTime = gameLocal.time;
	maxRespawnTime = gameLocal.time;
	if ( !spectating ) {
		forceRespawn = false;
	}

	privateCameraView = NULL;

	BecomeActive( TH_THINK );

	// HUMANHEAD pdm: Think moved after our initialization

	respawning			= false;
	lastManOver			= false;
	lastManPlayAgain	= false;
	isTelefragged		= false;
	// idPlayer::SpawnToPoint() code end---------------------------
	// ------------------------------------------------------------

	// aob - added because we might die while wallwalking
	physicsObj.SetGravity( -(spawn_angles.ToMat3()[2]) * gameLocal.GetGravity().Length() );
	physicsObj.SetAxis( idAngles( spawn_angles.pitch, 0.0f, spawn_angles.roll ).ToMat3() );
	physicsObj.CheckWallWalk( true );

	SetEyeHeight( pm_normalviewheight.GetFloat() );

	bob = 0.0f;
	lastAppliedBobCycle = 0.0f;
	cameraInterpolator.SetSelf( this );
	cameraInterpolator.Setup( p_camRotRateScale.GetFloat(), IT_VariableMidPointSinusoidal );
	cameraInterpolator.Reset( spawn_origin, idAngles(spawn_angles.pitch, 0.0f, spawn_angles.roll).ToMat3()[2], EyeHeightIdeal() );

	// Needed after parent call, as these are set in the parent call
	//HUMANHEAD: aob
	prevStepUpOrigin = cameraInterpolator.GetCurrentPosition();
	//HUMANHEAD END

	if ( !gameLocal.isMultiplayer ) { // Only recharge health and rifle ammo in single player
		lastDamagedTime = gameLocal.time; // CJR PCF 04/27/06:  Ensure that lastDamagedTime is set probably at level load
		PostEventSec( &EV_RechargeHealth, spawnArgs.GetFloat( "healthRechargeRate", "0.5" ) );
		PostEventSec( &EV_RechargeRifleAmmo, spawnArgs.GetFloat( "rifleAmmoRechargeRate", "2" ) );

		// Start the DDA update code
		PostEventSec( &EV_UpdateDDA, spawnArgs.GetFloat( "updateDDARate", "0.25" ) );
	}

	//HUMANHEAD pdm: Moved from id code above to be after our initialization
	// run a client frame to drop exactly to the floor,
	// initialize animations and other things
	Think();
}

/*
==============
hhPlayer::SetupWeaponEntity
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
==============
*/
void hhPlayer::SetupWeaponEntity( void ) {
	weapon.Clear();
	InvalidateCurrentWeapon();
}

/*
================
hhPlayer::ApplyImpulse
================
*/
void hhPlayer::ApplyImpulse( idEntity *ent, int id, const idVec3 &point, const idVec3 &impulse ) {
	if( ent && (ent->IsType(hhForceField::Type) || ent->IsType(hhDeathWraith::Type)) ) {
		idPlayer::ApplyImpulse( ent, id, point, impulse );
	}
}

/*
================
hhPlayer::CL_UpdateProgress
	Client function to update progress related variables
	called after getting a snapshot, or directly if a local client
================
*/
void hhPlayer::CL_UpdateProgress(bool bBar, float value, int state) {
	idUserInterface *_hud = NULL;

	if (InVehicle() && GetVehicleInterfaceLocal() && GetVehicleInterfaceLocal()->GetHUD()) {
		_hud = GetVehicleInterfaceLocal()->GetHUD();
	}
	else {
		_hud = hud;
	}

	// Update progress bar
	if (bBar && !bShowProgressBar) {
		_hud->HandleNamedEvent("ShowProgressBar");
	}
	else if (!bBar && bShowProgressBar) {
		_hud->HandleNamedEvent("HideProgressBar");
	}

	// See if we just entered a victory state
	if (state != progressBarState) {
		switch (state) {
			case 0:
				_hud->HandleNamedEvent("ProgressNone");
				break;
			case 1:
				_hud->HandleNamedEvent("ProgressVictory");
				break;
			case 2:
				_hud->HandleNamedEvent("ProgressFailure");
				break;
		}
	}

	// Interpolate gui value to target value
	float curValue = progressBarGuiValue.GetCurrentValue(gameLocal.time);
	progressBarGuiValue.Init(gameLocal.time, 500, curValue, value);

	// Update variables
	bShowProgressBar = bBar;
	progressBarValue = value;
	progressBarState = state;
}

// This called once per tick, put things in here that should be updated regardless of frame rate
//	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
void hhPlayer::UpdateHud( idUserInterface *_hud ) {
	idPlayer *aimed;

	if ( !_hud ) {
		return;
	}

	if ( entityNumber != gameLocal.localClientNum ) {
		return;
	}

#define PICKUPTIME_FADEIN_START		0
#define PICKUPTIME_FADEIN_END		500
#define PICKUPTIME_FADEOUT_START	1750
#define PICKUPTIME_FADEOUT_END		2000
#define MULTIPLEITEM_SPEEDUP		7
	int c = inventory.pickupItemNames.Num();
	int time;
	int i;
	int pickupTimeFadeInStart, pickupTimeFadeInStop, pickupTimeFadeOutStart, pickupTimeFadeOutStop;
	float scale = 1.0f / (((c-1.0f)/9.0f) * (MULTIPLEITEM_SPEEDUP-1.0f) + 1.0f);
	pickupTimeFadeInStart = PICKUPTIME_FADEIN_START;
	pickupTimeFadeInStop = PICKUPTIME_FADEIN_END;
	pickupTimeFadeOutStart = PICKUPTIME_FADEOUT_START * scale;
	pickupTimeFadeOutStop = PICKUPTIME_FADEOUT_END * scale;

	// Determine fade in color for icons
	if (c > 0) {
		for ( i = 0; i < c; i++ ) {
			inventory.pickupItemNames[i].time += gameLocal.msec;
			time = inventory.pickupItemNames[i].time;

			if (time < pickupTimeFadeInStart) {
				inventory.pickupItemNames[i].matcolorAlpha = 0.0f;
			}
			else if (time < pickupTimeFadeInStop) {
				inventory.pickupItemNames[i].matcolorAlpha = ((float)(time-pickupTimeFadeInStart))/(pickupTimeFadeInStop-pickupTimeFadeInStart);
			}
			else {
				inventory.pickupItemNames[i].matcolorAlpha = 1.0f;
			}
		}
	
		// Determine fadeout of slot zero icon
		inventory.pickupItemNames[0].slotZeroTime += gameLocal.msec;
		time = inventory.pickupItemNames[0].slotZeroTime;
		if (time < pickupTimeFadeOutStart) {
			inventory.pickupItemNames[0].matcolorAlpha = 1.0f;
		}
		else if (time < pickupTimeFadeOutStop) {
			inventory.pickupItemNames[0].matcolorAlpha = 1.0f - ((float)(time-pickupTimeFadeOutStart))/(pickupTimeFadeOutStop-pickupTimeFadeOutStart);
		}
		else {
			inventory.pickupItemNames[0].matcolorAlpha = 0.0f;
		}

		// Remove any expired icons
		time = inventory.pickupItemNames[0].slotZeroTime;
		if (time > pickupTimeFadeOutStop) {
			// icon has faded out, remove from list and slide them down
			inventory.pickupItemNames.RemoveIndex(0);
		}
	}

	// HUMANHEAD pdm: Changed aim logic to always show color-coded aimee
	if ( MPAim != -1 && gameLocal.entities[ MPAim ]
			&& gameLocal.entities[ MPAim ]->IsType( idPlayer::Type ) ) {

		aimed = static_cast< idPlayer * >( gameLocal.entities[ MPAim ] );
		_hud->SetStateString( "aim_text", gameLocal.userInfo[ MPAim ].GetString( "ui_name" ) );
		idVec4 teamColor = aimed->GetTeamColor();
		_hud->SetStateFloat( "aim_R", teamColor.x );
		_hud->SetStateFloat( "aim_G", teamColor.y );
		_hud->SetStateFloat( "aim_B", teamColor.z );

		//HUMANHEAD rww - health display on hud for gameplay testing
		if (g_showAimHealth.GetBool()) {
			_hud->SetStateInt("aim_health", gameLocal.entities[MPAim]->health);
		}
		//HUMANHEAD END
	}
	else {
		_hud->SetStateString( "aim_text", "" );

		//HUMANHEAD rww
		_hud->SetStateInt("aim_health", 0);
		//HUMANHEAD END
	}

#if !GOLD
	_hud->SetStateInt( "g_showProjectilePct", g_showProjectilePct.GetInteger() );
	if ( numProjectilesFired ) {
		_hud->SetStateString( "projectilepct", va( "Hit %% %.1f", ( (float) numProjectileHits / numProjectilesFired ) * 100 ) );
	} else {
		_hud->SetStateString( "projectilepct", "Hit % 0.0" );
	}
#endif

	if (gameLocal.isNewFrame) { //HUMANHEAD rww - only on newframe
		// Update low health sound
		if ( health > 0 && health < 25 && !IsSpiritOrDeathwalking() ) {
			if (!bPlayingLowHealthSound) {
				StartSound("snd_lowhealth", SND_CHANNEL_HEART, 0, false, NULL);
				bPlayingLowHealthSound = true;
			}
		}
		else {
			if (bPlayingLowHealthSound) {
				StopSound(SND_CHANNEL_HEART, false);
				bPlayingLowHealthSound = false;
			}
		}
	}

	// Handle damage indictors
	idVec3 localDamageVector;
	idVec3 toEnemy;
	for (int ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		if (lastAttackers[ix].attacker.IsValid()) {

			if (!lastAttackers[ix].displayed) {
				_hud->HandleNamedEvent( va("Attacked%i", ix) );//Notify hud we were attacked
				_hud->SetStateBool("displayDamageIndicators", true);
				lastAttackers[ix].displayed = true;
			}

			toEnemy = lastAttackers[ix].attacker->GetOrigin() - GetOrigin();
			toEnemy.z = 0.0f;
			GetAxis().ProjectVector( toEnemy, localDamageVector );
			float yawToEnemy = idMath::AngleNormalize180(localDamageVector.ToYaw());
			_hud->SetStateFloat( va("yawToEnemy%i", ix), yawToEnemy);
			if (gameLocal.time > lastAttackers[ix].time + DAMAGE_INDICATOR_TIME) {
				lastAttackers[ix].attacker = NULL;

				bool allExpired = true;
				for (int jx=0; jx<MAX_TRACKED_ATTACKERS; jx++) {
					if (lastAttackers[jx].attacker.IsValid()) {
						allExpired = false;
						break;
					}
				}
				if (allExpired) {
					_hud->SetStateBool("displayDamageIndicators", false);
				}
			}
		}
	}

	if (gameLocal.isMultiplayer) {
		bool bLagged = isLagged && gameLocal.isMultiplayer && (gameLocal.localClientNum == entityNumber);
		_hud->SetStateBool("hudLag", bLagged);
	}
	// HUMANHEAD PCF pdm 06-26-06: Fix for multiplayer shuttle hud elements appearing in SP after a MP session
	else {
		_hud->SetStateBool( "ismultiplayer", false );
	}
	// HUMANHEAD END
}

//	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
void hhPlayer::UpdateHudWeapon(bool flashWeapon) {
	idUserInterface *_hud = hhPlayer::hud;

	// if updating the hud of a followed client
	if ( gameLocal.localClientNum >= 0 && gameLocal.entities[ gameLocal.localClientNum ] && gameLocal.entities[ gameLocal.localClientNum ]->IsType( idPlayer::Type ) ) {
		idPlayer *p = static_cast< idPlayer * >( gameLocal.entities[ gameLocal.localClientNum ] );
		if ( p->spectating && p->spectator == entityNumber ) {
			assert( p->hud );
			_hud = p->hud;
		}
	}

	if ( _hud ) {
		// HUMANHEAD pdm: changed to suit our needs
		_hud->SetStateInt( "currentweapon", GetCurrentWeapon() );
		_hud->SetStateInt( "idealweapon", GetIdealWeapon() );
		//HUMANHEAD PCF mdl 05/05/06 - Added !IsLocked( GetIdealWeapon() )
		if ( flashWeapon && !IsLocked( GetIdealWeapon() ) ) {
			_hud->HandleNamedEvent( "weaponChange" );
		}
	}
}

//	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
void hhPlayer::UpdateHudAmmo(idUserInterface *_hud) {
	assert( _hud );
	float ammoPct, altPct;
	int ammoType, altAmmoType;
	float ammo, altAmmo;
	bool ammoLow, altAmmoLow;

	// HUMANHEAD pdm: Weapon switch overlay, using rover to spread the expense over frames
	static int rover = 0;
	if (++rover > 9) {
		rover = 0;
	}

	if (rover) {
		bool bHeld = false;
		ammoPct = 0.0f;
		altPct = 0.0f;
		ammoType = weaponInfo[rover].ammoType;
		altAmmoType = altWeaponInfo[rover].ammoType;
		ammo = inventory.ammo[ammoType];
		altAmmo = inventory.ammo[altAmmoType];
		ammoLow = false;
		altAmmoLow = false;

		if ( inventory.weapons & ( 1 << rover ) ) {
			// have this weapon
			bHeld = true;
			ammoPct = ammo / weaponInfo[rover].ammoMax;
			altPct = altAmmo / altWeaponInfo[rover].ammoMax;
			ammoLow = ammo > 0 && ammo <= weaponInfo[rover].ammoLow;
			altAmmoLow = altAmmo > 0 && altAmmo <= altWeaponInfo[rover].ammoLow;
		}

		// Spirit ammo doesn't display in a bar
		if ( ammoType == 1 ) {
			ammoType = 0;
			altAmmoType = 0;
		}

		// Zero out alt-ammo bar if appropriate
		if (altAmmoType == 0 || altAmmoType == ammoType) {
			altPct = 0.0f;
		}

		_hud->SetStateBool (va("weapon%d_held", rover), bHeld);
		_hud->SetStateBool (va("weapon%d_ammolow", rover), ammoLow);
		_hud->SetStateBool (va("weapon%d_altammolow", rover), altAmmoLow);
		_hud->SetStateFloat(va("weapon%d_ammo", rover), ammoPct);
		_hud->SetStateFloat(va("weapon%d_altammo", rover), altPct);
		_hud->SetStateBool (va("weapon%d_ammoempty", rover), ammoType != 0 && ammo == 0 && altAmmo == 0);
	}

	// Update the current weapon's ammo status
	bool bDisallowAmmoBars = false;
	ammoPct = 0.0f;
	altPct = 0.0f;
	ammoLow = false;
	altAmmoLow = false;
	ammoType = 0;
	altAmmoType = 0;
	ammo = 0;
	altAmmo = 0;

	if( bLotaTunnelMode || privateCameraView || IsLocked(idealWeapon) || !weapon.IsValid() || !weapon->IsLinked() || currentWeapon == -1) {
		// Don't display ammo bar for invalid weapons, or when weapons are locked
		bDisallowAmmoBars = true;
	}
	else {
		if (currentWeapon >= 0 && currentWeapon < 15) {
			ammoType = weaponInfo[currentWeapon].ammoType;
			altAmmoType = altWeaponInfo[currentWeapon].ammoType;
			ammo = inventory.ammo[ammoType];
			altAmmo = inventory.ammo[altAmmoType];
			ammoPct = ammo / weaponInfo[currentWeapon].ammoMax;
			altPct = altAmmo / altWeaponInfo[currentWeapon].ammoMax;
			ammoLow = ammo > 0 && ammo <= weaponInfo[currentWeapon].ammoLow;
			altAmmoLow = altAmmo > 0 && altAmmo <= altWeaponInfo[currentWeapon].ammoLow;
		}

		if (ammoType == 1) {
			bDisallowAmmoBars = true;
		}
	}

	if ( bDisallowAmmoBars ) {
		_hud->SetStateBool( "player_ammobar", false);
		_hud->SetStateBool( "player_altammobar", false );
	}
	else {
		_hud->SetStateBool( "player_ammobar", ammoType != 0);
		_hud->SetStateBool( "player_altammobar", altAmmoType != 0 && altAmmoType != ammoType );

		_hud->SetStateFloat( "player_ammopercent", ammoPct );
		_hud->SetStateFloat( "player_altammopercent", altPct );
		_hud->SetStateString( "player_ammoamounttext", ammo<0 ? "" : va("%d", ammo) );
		_hud->SetStateString( "player_altammoamounttext", altAmmo<0 ? "" : va("%d", altAmmo) );
		_hud->SetStateBool( "player_ammolow", ammoLow );
		_hud->SetStateBool( "player_altammolow", altAmmoLow );
	}

}

/*
================
hhPlayer::UpdateHudStats
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
================
*/
void hhPlayer::UpdateHudStats( idUserInterface *_hud ) {

	assert( _hud );

	int spiritPower = GetSpiritPower();

	// Disallow health if wrench is locked on a non-lota map --or-- if in a private camera
	bool disallowHealth = bLotaTunnelMode || (IsLocked(1) && !gameLocal.IsLOTA()) || privateCameraView != NULL;
	bool disallowProgress = bLotaTunnelMode || privateCameraView != NULL || IsDeathWalking();

	if (disallowHealth) {
		int blah = 0;
	}
	else {
		int blah2 = 0;
	}

	_hud->SetStateBool("invehicle", InVehicle());
	_hud->SetStateBool("deathwalking", IsDeathWalking());
	_hud->SetStateBool("spiritwalking", IsSpiritWalking());
	_hud->SetStateBool("lighter", IsLighterOn() );
	_hud->SetStateBool("showhealth", !disallowHealth);
	_hud->SetStateBool("allowprogress", !disallowProgress);
	_hud->SetStateBool("showspiritpower", (!disallowHealth && !InVehicle() && (inventory.requirements.bCanSpiritWalk || IsDeathWalking())));
	_hud->SetStateFloat("lightertemp", lighterTemperature);
	_hud->SetStateFloat( "player_spiritpercent", ((float)spiritPower)/inventory.maxSpirit );
	_hud->SetStateFloat( "player_healthpercent", ((float)health)/inventory.maxHealth );
	_hud->SetStateFloat( "player_healthR", inventory.maxHealth > 100 ? 0.75f : 0.6f );
	_hud->SetStateFloat( "player_healthG", inventory.maxHealth > 100 ? 0.85f : 0.0f );
	_hud->SetStateFloat( "player_healthB", inventory.maxHealth > 100 ? 1.0f : 0.0f );
	_hud->SetStateFloat( "player_healthPulseR", inventory.maxHealth > 100 ? 1.0f : 1.0f );
	_hud->SetStateFloat( "player_healthPulseG", inventory.maxHealth > 100 ? 1.0f : 0.0f );
	_hud->SetStateFloat( "player_healthPulseB", inventory.maxHealth > 100 ? 1.0f : 0.0f );
	_hud->SetStateInt( "player_health", health );
	_hud->SetStateInt( "player_maxhealth", inventory.maxHealth ); //rww
	_hud->SetStateString( "player_spirit", spiritPower<0 ? "0" : va("%d", spiritPower) );
	_hud->SetStateFloat( "progress", progressBarGuiValue.GetCurrentValue(gameLocal.time) );

	if ( healthPulse ) {
		_hud->HandleNamedEvent( "healthPulse" );
		StartSound( "snd_healthpulse", SND_CHANNEL_ITEM, 0, false, NULL );
		healthPulse = false;
	}
	if ( spiritPulse ) {
		_hud->HandleNamedEvent( "spiritPulse" );
		StartSound( "snd_spiritpulse", SND_CHANNEL_ITEM, 0, false, NULL );
		spiritPulse = false;
	}

	if ( inventory.ammoPulse ) { 
		_hud->HandleNamedEvent( "ammoPulse" );
		inventory.ammoPulse = false;
	}
	if ( inventory.weaponPulse ) {
		// We need to update the weapon hud manually, but not
		// the armor/ammo/health because they are updated every
		// frame no matter what
		UpdateHudWeapon();
		_hud->HandleNamedEvent( "weaponPulse" );
		inventory.weaponPulse = false;
	}

	UpdateHudAmmo( _hud );

	// Determine slots for our pickup icons
	int c = inventory.pickupItemNames.Num();
	for ( int i=0; i<10; i++ ) {
		if (i<c) {
			_hud->SetStateString( va( "itemicon%i", i ), inventory.pickupItemNames[i].icon );
			_hud->SetStateFloat( va( "itemalpha%i", i ), inventory.pickupItemNames[i].matcolorAlpha );
			_hud->SetStateBool( va( "itemwide%i", i), inventory.pickupItemNames[i].bDoubleWide );
		}
		else {
			_hud->SetStateString( va( "itemicon%i", i ), "" );
			_hud->SetStateFloat( va( "itemalpha%i", i ), 0.0f );
			_hud->SetStateBool( va( "itemwide%i", i), false );
		}
	}
}

/*
===============
hhPlayer::DrawHUD
	HUMANHEAD: This run only for local players
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::DrawHUD( idUserInterface *_hud ) {

	if (guiOverlay) {
		guiOverlay->Redraw(gameLocal.realClientTime);
		sysEvent_t ev;
		const char *command;
		ev = sys->GenerateMouseMoveEvent( -2000, -2000 );
		command = guiOverlay->HandleEvent( &ev, gameLocal.time );
// 		HandleGuiCommands( this, command );
		return;
	}

	// HUMANHEAD pdm: removed weapon ptr check here since ours is invalid when in a vehicle
	// Also removed privateCameraView, since we want subtitles when they are on
	if ( gameLocal.GetCamera() || !_hud || !g_showHud.GetBool() || pm_thirdPerson.GetBool() ) {
		return;
	}

	UpdateHudStats( _hud );


	if(weapon.IsValid()) { // HUMANHEAD
		bool allowGuiUpdate = true;
		//rww - update the weapon gui only if the owner is being spectated by this client, or is this client
		if ( gameLocal.localClientNum != entityNumber ) {
			// if updating the hud for a followed client
			if ( gameLocal.localClientNum >= 0 && gameLocal.entities[ gameLocal.localClientNum ] && gameLocal.entities[ gameLocal.localClientNum ]->IsType( idPlayer::Type ) ) {
				idPlayer *p = static_cast< idPlayer * >( gameLocal.entities[ gameLocal.localClientNum ] );
				if ( !p->spectating || p->spectator != entityNumber ) {
					allowGuiUpdate = false;
				}
			} else {
				allowGuiUpdate = false;
			}
		}

		if (allowGuiUpdate) {
			weapon->UpdateGUI();
		}
	}

	_hud->SetStateInt( "s_debug", cvarSystem->GetCVarInteger( "s_showLevelMeter" ) );

	//HUMANHEAD aob: vehicle logic
	if ( InVehicle() ) {
		DrawHUDVehicle( _hud );
	}
	else {
		_hud->Redraw( gameLocal.realClientTime );
	}
	//HUMANHEAD END

	// weapon targeting crosshair
	if ( !GuiActive() ) {
		if ( cursor ) {
			UpdateCrosshairs();
			cursor->Redraw( gameLocal.realClientTime );
		}
	}
}

/*
===============
hhPlayer::DrawHUDVehicle
	HUMANHEAD: This run only for local players
===============
*/
void hhPlayer::DrawHUDVehicle( idUserInterface* _hud ) {
	if (GetVehicleInterfaceLocal()) {
		GetVehicleInterfaceLocal()->DrawHUD( _hud );
	}
}

/*
===============
hhPlayer::FireWeapon
===============
*/
void hhPlayer::FireWeapon( void ) {
	idMat3 axis;
	idVec3 muzzle;

	if ( privateCameraView ) {
		return;
	}

	if ( g_editEntityMode.GetInteger() ) {
		GetViewPos( muzzle, axis );
		if ( gameLocal.editEntities->SelectEntity( muzzle, axis[0], this ) ) {
			return;
		}
	}

	//HUMANHEAD: aob - removed ammo check because we allow weapons to change modes
	if( weapon.IsValid() ) {
		AI_ATTACK_HELD = true;
		weapon->BeginAttack();
	}
	//HUMANEHAD END
}

//=========================================================================
//
// hhPlayer::FireWeaponAlt
//
//=========================================================================

void hhPlayer::FireWeaponAlt( void ) {
	idMat3 axis;
	idVec3 muzzle;

	if ( privateCameraView ) {
		return;
	}

	if ( g_editEntityMode.GetBool() ) {
		GetViewPos( muzzle, axis );
		if ( gameLocal.editEntities->SelectEntity( muzzle, axis[0], NULL ) ) {
			return;
		}
	}

	if ( gameLocal.isMultiplayer && spectating ) {
		static int lastSpectatorSwitch = 0;
		if ( gameLocal.time > lastSpectatorSwitch + 500 ) {
			spectator = gameLocal.GetNextClientNum( spectator );
			idPlayer *player = gameLocal.GetClientByNum( spectator );
			while ( player->spectating && player != this ) {
				player = gameLocal.GetClientByNum(spectator);
			}
			lastSpectatorSwitch = gameLocal.time;
		}
		return;
	}

	//HUMANHEAD: aob - removed ammo check because we allow weapons to change modes
	if( weapon.IsValid() ) {
		AI_ATTACK_HELD = true;
		weapon->BeginAltAttack();
	}
	//HUMANEHAD END

	if ( hud ) {
		hud->HandleNamedEvent( "closeObjective" );
	}
}

void hhPlayer::StopFiring( void ) {
	idPlayer::StopFiring();
	if ( weapon.GetEntity() && weapon->IsType( hhWeaponRifle::Type ) ) {
		static_cast<hhWeaponRifle*>( weapon.GetEntity() )->ZoomOut();
	}
}

/*
===============
hhPlayer::HasAmmo
===============
*/
int hhPlayer::HasAmmo( ammo_t type, int amount ) {
	return inventory.HasAmmo( type, amount );
}

/*
===============
hhPlayer::UseAmmo
===============
*/
bool hhPlayer::UseAmmo( ammo_t type, int amount ) {
	return inventory.UseAmmo( type, amount );
}

/*
===============
hhPlayer::NextBestWeapon
===============
*/
void hhPlayer::NextBestWeapon( void ) {
	if ( ActiveGui() || IsSpiritOrDeathwalking() ) {
		return;
	}
	idPlayer::NextBestWeapon();
}

/*
===============
hhPlayer::SelectWeapon
===============
*/
void hhPlayer::SelectWeapon( int num, bool force ) {	
	if ( ! ( weaponFlags & ( 1 << ( num - 1 ) ) ) ) {
		return;
	}
	if ( bFrozen || ActiveGui() || ( SkipWeapon(num) || IsSpiritOrDeathwalking() ) ) {
		return;
	}
	idPlayer::SelectWeapon( num, force );
}

/*
===============
hhPlayer::NextWeapon
===============
*/
void hhPlayer::NextWeapon( void ) {
	if ( ActiveGui() || IsSpiritOrDeathwalking() || bFrozen ) {
		// NOTE: Spirit weapon is disallowed from being cycled to using the weapon*_cycle key
		return;
	}
	//idPlayer::NextWeapon();
	if ( !weaponEnabled || spectating || hiddenWeapon || gameLocal.inCinematic || privateCameraView || gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) || health < 0 ) {
		return;
	}

	if ( gameLocal.isClient ) {
		return;
	}

	// check if we have any weapons
	if ( !inventory.weapons ) {
		return;
	}

	const char *weap;
	int w, start;

	w = idealWeapon;
	start = w;
	while( 1 ) {
		w++;
		if ( w >= MAX_WEAPONS ) {
			// No weapon selected and nothing to select
			if ( start == -1 ) {
				idealWeapon = 0;
				currentWeapon = 0;
				return;
			}
			w = 0;
		}
		// Keep us from an infinite loop if no weapons are valid
		if ( w == start ) {
			if ( ! ( weaponFlags & ( 1 << ( w - 1 ) ) ) ) {
				idealWeapon = 0;
				currentWeapon = 0;
			}
			return;
		}
		weap = spawnArgs.GetString( va( "def_weapon%d", w ) );
		if ( !spawnArgs.GetBool( va( "weapon%d_cycle", w ) ) ) {
			continue;
		}
		if ( !weap[ 0 ] ) {
			continue;
		}
		if ( ( inventory.weapons & ( 1 << w ) ) == 0 ) {
			continue;
		}
		// Make sure the weapon is valid for this level
		if ( ! ( weaponFlags & ( 1 << ( w - 1 ) ) ) ) {
			continue;
		}
		if ( inventory.HasAmmo( weap ) || inventory.HasAltAmmo( weap ) || spawnArgs.GetBool( va( "weapon%d_allowempty", w ) ) ) {
			break;
		}
	}

	if ( ( w != currentWeapon ) && ( w != idealWeapon ) ) {
		idealWeapon = w;
		weaponSwitchTime = gameLocal.time + WEAPON_SWITCH_DELAY;
		UpdateHudWeapon();
	}
}

/*
===============
hhPlayer::PrevWeapon
===============
*/
void hhPlayer::PrevWeapon( void ) {
	if ( ActiveGui() || IsSpiritOrDeathwalking() || bFrozen ) {
		// NOTE: Spirit weapon is disallowed from being cycled to using the weapon*_cycle key
		return;
	}
	//idPlayer::PrevWeapon();
	if ( !weaponEnabled || spectating || hiddenWeapon || gameLocal.inCinematic || privateCameraView || gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) || health < 0 ) {
		return;
	}

	if ( gameLocal.isClient ) {
		return;
	}

	// check if we have any weapons
	if ( !inventory.weapons ) {
		return;
	}

	const char *weap;
	int w = idealWeapon, start = w;
	if (w == -1) {
		w = MAX_WEAPONS - 1;
	}
	while( 1 ) {
		w--;
		if ( w < 0 ) {
			// No weapon selected and nothing to select
			if ( start == -1 ) {
				idealWeapon = 0;
				currentWeapon = 0;
				return;
			}

			w = MAX_WEAPONS - 1;
		}
		// Keep us from an infinite loop if no weapons are valid
		if ( w == start ) {
			if ( ! ( weaponFlags & ( 1 << ( w - 1 ) ) ) ) {
				idealWeapon = 0;
				currentWeapon = 0;
			}
			return;
		}
		weap = spawnArgs.GetString( va( "def_weapon%d", w ) );
		if ( !spawnArgs.GetBool( va( "weapon%d_cycle", w ) ) ) {
			continue;
		}
		if ( !weap[ 0 ] ) {
			continue;
		}
		if ( ( inventory.weapons & ( 1 << w ) ) == 0 ) {
			continue;
		}
		// Make sure the weapon is valid for this level
		if ( ! ( weaponFlags & ( 1 << ( w - 1 ) ) ) ) {
			continue;
		}
		if ( inventory.HasAmmo( weap ) || inventory.HasAltAmmo( weap ) || spawnArgs.GetBool( va( "weapon%d_allowempty", w ) ) ) {
			break;
		}
	}

	if ( ( w != currentWeapon ) && ( w != idealWeapon ) ) {
		idealWeapon = w;
		weaponSwitchTime = gameLocal.time + WEAPON_SWITCH_DELAY;
		UpdateHudWeapon();
	}
}

/*
===============
hhPlayer::SkipWeapon
===============
*/
bool hhPlayer::SkipWeapon( int weaponNum ) const {
	//No bow if not in spirit mode
	return !IsSpiritOrDeathwalking() && weaponNum == spawnArgs.GetInt("spirit_weapon");
}

/*
===============
hhPlayer::SnapDownCurrentWeapon

HUMANHEAD: aob
===============
*/
void hhPlayer::SnapDownCurrentWeapon() {
	if( weapon.IsValid() ) {
		weapon->SnapDown();
	}
}

/*
===============
hhPlayer::SnapUpCurrentWeapon

HUMANHEAD: aob
===============
*/
void hhPlayer::SnapUpCurrentWeapon() {
	if( weapon.IsValid() ) {
		weapon->SnapUp();
	}
}

/*
===============
hhPlayer::SelectEtherealWeapon

HUMANHEAD: aob
===============
*/
void hhPlayer::SelectEtherealWeapon() {
	if ( GetCurrentWeapon() != 0 ) {
		lastWeaponSpirit = GetCurrentWeapon();
	}

	weaponHandState.SetPlayer( this );
	if (!gameLocal.isClient) {
		int spiritWeaponIndex = spawnArgs.GetInt("spirit_weapon");
		const char *spiritWeaponName = NULL;
		if (bDeathWalk || (inventory.weapons & (1 << spiritWeaponIndex)) ) {
			spiritWeaponName = GetWeaponName(spiritWeaponIndex);
		}
		weaponHandState.Archive( spiritWeaponName, 0, (InGUIMode()) ? "guihand_normal" : NULL );
	}

	if ( weapon.IsValid() ) {
		weapon->SetShaderParm( SHADERPARM_MODE, MS2SEC( gameLocal.time ) ); // Glow in the bow
		weapon->SetShaderParm( SHADERPARM_MISC, 1.0f ); // Turn on the arrow
		weapon->SetShaderParm( SHADERPARM_DIVERSITY, MS2SEC( gameLocal.time ) ); // Glow in the arrow
	}
}

/*
===============
hhPlayer::PutawayEtherealWeapon

HUMANHEAD: aob
===============
*/
void hhPlayer::PutawayEtherealWeapon() {
	//If we haven't actually changed weapons yet, put current weapon up
	if( GetCurrentWeapon() != lastWeaponSpirit ) {
		SnapDownCurrentWeapon();
	} else {
		SnapUpCurrentWeapon();
	}

	weaponHandState.RestoreFromArchive();
}

/*
===============
hhPlayer::UpdateWeapon
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::UpdateWeapon( void ) {
	
	if ( IsDead() ) { // HUMANHEAD cjr:  Replaced health <= 0 with IsDead() call for deathwalk override
		return;
	}

	assert( !spectating );

	if ( gameLocal.isClient ) {
		// clients need to wait till the weapon and it's world model entity
		// are present and synchronized ( weapon.worldModel idEntityPtr to idAnimatedEntity )
		if ( !weapon.GetEntity()->IsWorldModelReady() ) {
			return;
		}
	}
	else if (gameLocal.isMultiplayer) { //rww - projectile deferring
		if (weapon.IsValid()) {
			weapon->CheckDeferredProjectiles();
		}
	}

	// always make sure the weapon is correctly setup before accessing it
	if ( weapon.GetEntity() && !weapon.GetEntity()->IsLinked() ) {
		if ( idealWeapon != -1 ) {
			animPrefix = spawnArgs.GetString( va( "def_weapon%d", idealWeapon ) );
			weapon.GetEntity()->GetWeaponDef( animPrefix, inventory.clip[ idealWeapon ] );
			animPrefix.Strip( "weaponobj_" ); //HUMANHEAD rww
			assert( weapon.GetEntity()->IsLinked() );
		} else {
			return;
		}
	}

	//HUMANEHAD rww
	if (weapon.IsValid() && weapon->IsType(hhWeaponSoulStripper::Type)) {
		hhWeaponSoulStripper *leechGun = static_cast<hhWeaponSoulStripper *>(weapon.GetEntity());
		leechGun->CheckCans();
	}
	//HUMANHEAD END

	if (!InVehicle()) {
		if ( g_dragEntity.GetBool() ) {
			StopFiring();
			dragEntity.Update( this );
			if ( weapon.IsValid() ) {
				weapon.GetEntity()->FreeModelDef();
			}
			return;
		} else if (ActiveGui()) {
			// gui handling overrides weapon use
			Weapon_GUI();
		} else {
			Weapon_Combat();
		}

		// Determine whether we are in aside state
		if ( weapon.IsValid() && weapon->IsAside() ) {
			if ( !AI_ASIDE ) {
				AI_ASIDE = true;
				SetState( "AsideWeapon" );
				UpdateScript();
			}
		} else {
			AI_ASIDE = false;
		}
	}

	//HUMANHEAD: aob - added weapon validity check
	if( weapon.IsValid() ) {
		// update weapon state, particles, dlights, etc
		weapon->PresentWeapon( showWeaponViewModel );
	}

	// nla
	if ( hand.IsValid() ) {
		hand->Present();
	}
}

/*
===============
hhPlayer::InGUIMode
nla - Used for the GUI hand to check if it should be up.  (Coming back from spiritwalk)
===============
*/
bool hhPlayer::InGUIMode() {

	// Logic adapted from UpdateWeapon
	if ( ActiveGui() && !InVehicle() ) {
		return( true );
	}

	return( false );
}


/*
===============
hhPlayer::Weapon_Combat
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::Weapon_Combat( void ) {
	idMat3		axis;
	idVec3		muzzle;
	idDict		args;
	
	if ( !weaponEnabled || gameLocal.inCinematic || privateCameraView ) {
		return;
	}

	// HUMANHEAD nla
	if ( hand.IsValid() && hand->IsType( hhGuiHand::Type ) && hand->IsAttached() && !hand->IsLowering() ) { 
		hand->RemoveHand();
	}	
	// HUMANHEAD END

	if( idealWeapon != 0 && IsLocked(idealWeapon) ) {		//HUMANHEAD bjk PCF (4-30-06) - fix wrench up in roadhouse
		NextWeapon();
	}

	if ( idealWeapon == 0 ) {
		return;
	}

	RaiseWeapon();
	if ( weapon.IsValid() ) {
		weapon.GetEntity()->PutUpright();
	}

	if ( weapon.IsValid() && weapon->IsReloading() ) {
		if ( !AI_RELOAD ) {
			AI_RELOAD = true;
			SetState( "ReloadWeapon" );
			UpdateScript();
		}
	} else {
		AI_RELOAD = false;
	}

	if ( idealWeapon != currentWeapon && (!gameLocal.isMultiplayer || inventory.lastShot[idealWeapon] < gameLocal.time) ) {	//HUMANHEAD bjk PATCH 7-27-06
		if ( weaponCatchup ) {
			assert( gameLocal.isClient );
#ifndef HUMANHEAD //HUMANHEAD rww FIXME!!!! this also produces horrible memory leaks because of the dirty fire controller stuff
			//HUMANHEAD rww - our crazy weapon system does not work ok with this. did we change the weapon dictionary parsing?
			//it seems that it is very much dependant on the base class of weapon at the moment and that of course is going to be
			//that of currentWeapon and not idealWeapon.
			//currentWeapon = idealWeapon;
			//HUMANHEAD END
			weaponGone = false;
			animPrefix = spawnArgs.GetString( va( "def_weapon%d", currentWeapon ) );
			weapon.GetEntity()->GetWeaponDef( animPrefix, inventory.clip[ currentWeapon ] );
			animPrefix.Strip( "weaponobj_" );	//HUMANHEAD pdm: changed from weapon_ to weaponobj_ per our naming convention

			weapon.GetEntity()->NetCatchup();
			const function_t *newstate = GetScriptFunction( "NetCatchup" );
			if ( newstate ) {
				SetState( newstate );
				UpdateScript();
			}
#else
			assert( idealWeapon >= 0 );
			assert( idealWeapon < MAX_WEAPONS );

			animPrefix = spawnArgs.GetString( va( "def_weapon%d", idealWeapon ) );
			const char *currentWeaponName = weapon->spawnArgs.GetString("classname", "");
			//make sure the weapon i have from my snapshot, and the weapon i have selected are the same.
			if (currentWeaponName && !idStr::Cmp(animPrefix, currentWeaponName)) {
				weaponGone = false;
				currentWeapon = idealWeapon;

				weapon->GetWeaponDef( animPrefix, inventory.clip[ currentWeapon ] );
				animPrefix.Strip( "weaponobj_" );
				weapon->Raise();
#endif //HUMANHEAD END
				weaponCatchup = false;			
			}
		} else {
			if ( weapon.IsValid() && (weapon->IsReady() || weapon->IsRising()) ) {
				InvalidateCurrentWeapon();//Needed incase we change weapons quickly, we can go back to old weapon
				weapon->PutAway();
			}

			if ( ( !weapon.IsValid() || weapon->IsHolstered() ) && !bDeathWalk && ! bReallyDead ) {
				assert( idealWeapon >= 0 );
				assert( idealWeapon < MAX_WEAPONS );

				if ( currentWeapon > 0 && !spawnArgs.GetBool( va( "weapon%d_toggle", currentWeapon ) ) ) {	//HUMANHEAD bjk
					previousWeapon = currentWeapon;
				}
				//HUMANHEAD PCF rww 05/03/06 - the local client might get skippiness between switching weapons if we
				//attempt to raise the weapon again before validating that the weapon ent is of the type that we
				//already desire to switch to. this bug is introduced by the concept of switching out entities when
				//changing weapons (not client-friendly).
				if (gameLocal.isClient && entityNumber == gameLocal.localClientNum) {
					if (weapon.IsValid() && weapon->GetDict() && idStr::Icmp(weapon->GetDict()->GetString("classname"), GetWeaponName( idealWeapon )) == 0) {
						currentWeapon = idealWeapon;
						weaponGone = false;
						animPrefix = GetWeaponName( currentWeapon );
						animPrefix.Strip( "weaponobj_" );	//HUMANHEAD pdm: changed from weapon_ to weaponobj_ per our naming convention
						weapon.GetEntity()->Raise();
					}
				}
				//HUMANHEAD END
				else {
					currentWeapon = idealWeapon;
					weaponGone = false;
				
					//HUMANHEAD: aob
					animPrefix = GetWeaponName( currentWeapon );
					if (!gameLocal.isClient) {
						SAFE_REMOVE( weapon );
						weapon = SpawnWeapon( animPrefix.c_str() );
					}
					//HUMANHEAD END
						
					animPrefix.Strip( "weaponobj_" );	//HUMANHEAD pdm: changed from weapon_ to weaponobj_ per our naming convention

					//HUMANHEAD PCF rww 05/03/06 - safety check, make sure weapon is valid particularly for the client
					if (weapon.IsValid()) {
						weapon.GetEntity()->Raise();
					}
				}
			}
		}
	} else if (!bDeathWalk && !bReallyDead) {
		weaponGone = false;	// if you drop and re-get weap, you may miss the = false above 
		if ( weapon.IsValid() && weapon.GetEntity()->IsHolstered() ) {
			if ( !weapon.GetEntity()->AmmoAvailable() ) {
				// weapons can switch automatically if they have no more ammo
				NextBestWeapon();
			} else if( !gameLocal.isMultiplayer || inventory.lastShot[idealWeapon] < gameLocal.time ) {		//HUMANHEAD bjk PATCH 9-11-06
				weapon.GetEntity()->Raise();
				state = GetScriptFunction( "RaiseWeapon" );
				if ( state ) {
					SetState( state );
				}
			}
		}
	}

	if ( weapon.IsValid() ) {
		weapon->PrecomputeTraceInfo();
	}

	// check for attack
	AI_WEAPON_FIRED = false;
	if ( ( usercmd.buttons & BUTTON_ATTACK ) && !weaponGone ) {
		FireWeapon();
	} else if ( oldButtons & BUTTON_ATTACK ) {
		AI_ATTACK_HELD = false;
		if( weapon.IsValid() ) {
			weapon.GetEntity()->EndAttack();
		}
	}

	// HUMANHEAD
	if ( ( usercmd.buttons & BUTTON_ATTACK_ALT ) && !weaponGone ) {
		FireWeaponAlt();
	} else if ( oldButtons & BUTTON_ATTACK_ALT ) {
		AI_ATTACK_HELD = false;
		if( weapon.IsValid() ) {
			weapon.GetEntity()->EndAltAttack();
		}
	}
	// HUMANHEAD END

	// update our ammo clip in our inventory
	if ( weapon.IsValid() && ( currentWeapon >= 0 ) && ( currentWeapon < MAX_WEAPONS ) ) {
		inventory.clip[ currentWeapon ] = weapon->AmmoInClip();
		inventory.altMode[ currentWeapon ] = weapon->GetAltMode();
	}
}

/*
===============
hhPlayer::SpawnWeapon
===============
*/
hhWeapon* hhPlayer::SpawnWeapon( const char* name ) {
	hhWeapon*	weaponPtr = NULL;
	idDict		args;

	args.SetVector( "origin", GetEyePosition() );
	args.SetMatrix( "rotation", viewAngles.ToMat3() );
	weaponPtr = static_cast<hhWeapon*>( gameLocal.SpawnObject(name, &args) );
	weaponPtr->SetOwner( this );
	weaponPtr->Bind( this, true );
							
	//HUMANHEAD: aob - removed last two params
	weaponPtr->GetWeaponDef( name );

	return weaponPtr;
}

/*
=====================
hhPlayer::GetWeaponNum
	HUMANHEAD
=====================
*/
int hhPlayer::GetWeaponNum( const char* weaponName ) const {
	for( int i = 1; i < MAX_WEAPONS; ++i ) {
		if( !idStr::Icmp(GetWeaponName(i), weaponName) ) {
			return i;
		}
	}

	return 0;
}

/*
=====================
hhPlayer::GetWeaponName
	HUMANHEAD
=====================
*/
const char* hhPlayer::GetWeaponName( int num ) const {
	if( num < 1 || num >= MAX_WEAPONS ) {
		return NULL;
	}

	return spawnArgs.GetString( va("def_weapon%d", num) );
}

/*
===============
hhPlayer::Weapon_GUI
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::Weapon_GUI( void ) {

	StopFiring();
	weapon.GetEntity()->LowerWeapon();

	// NLANOTE - Same here
	// disable click prediction for the GUIs. handy to check the state sync does the right thing
	if ( gameLocal.isClient && !net_clientPredictGUI.GetBool() ) {
		return;
	}

	if ( health <= 0 || bDeathWalk ) {		//HUMANHEAD bjk PCF (5-5-06) - no hand stuff when dead
		return;
	}

	// HUMANHEAD nla 
	if ( !bDeathWalk ) { // mdl - Don't do hand stuff while deathwalking
		if ( hand.IsValid() && hand->IsType( hhGuiHand::Type ) ) {
			//if ( !hand->IsReady() && !hand->IsRaising() ) {
			if ( !hand->IsReady() && !hand->IsRaising() && !hand->IsLowering() ) {
				hand->Reraise();
			}
		}
		else if ( (!hand.IsValid() && weapon.IsValid() && !weapon->IsAside()  ) || 
				  (hand.IsValid() && !hand->IsType( hhGuiHand::Type ) && !hand->IsLowering() ) ||
				  (!hand.IsValid() && idealWeapon == 0 ) ) {
			if (!gameLocal.isClient) { //rww
				hhHand::AddHand( this, GetGuiHandInfo() );
			}
		}
	}
	// HUMANHEAD END
		
	if ( hand.IsValid() && ( oldButtons ^ usercmd.buttons ) & BUTTON_ATTACK ) {	//HUMANHEAD bjk: no waiting for ready
		sysEvent_t ev;
		const char *command = NULL;
		bool updateVisuals = false;
		
		idUserInterface *ui = ActiveGui();
		if ( ui ) {
			ev = sys->GenerateMouseButtonEvent( 1, ( usercmd.buttons & BUTTON_ATTACK ) != 0 );
			command = ui->HandleEvent( &ev, gameLocal.time, &updateVisuals );
			if ( updateVisuals && focusGUIent && ui == focusUI ) {
				focusGUIent->UpdateVisuals();
			}
		}
		if ( gameLocal.isClient ) {
			// we predict enough, but don't want to execute commands
			if (focusGUIent) {
				if ( hand.IsValid() && hand->IsType( hhGuiHand::Type ) && ev.evValue2) { //rww - still predict hand
					hand->SetAction( focusGUIent->spawnArgs.GetString( "pressAnim", "press" ) );	//HUMANHEAD bjk
					hand->Action();
				}
			}
			return;
		}
		if ( focusGUIent ) {
			HandleGuiCommands( focusGUIent, command );
			// HUMANHEAD nla - Added to handle the hand stuff.  = )
			if ( hand.IsValid() && hand->IsType( hhGuiHand::Type ) && ev.evValue2) {
				hand->SetAction( focusGUIent->spawnArgs.GetString( "pressAnim", "press" ) );	//HUMANHEAD bjk
				hand->Action();
			}
			// HUMANHEAD END
		} else {
			HandleGuiCommands( this, command );
		}
	}
}

/*
================
hhPlayer::UpdateCrosshairs
HUMANHEAD PDM
================
*/
void hhPlayer::UpdateCrosshairs() {
	bool combatCrosshair = false;
	bool targeting = false;
	int crosshair = 0;

	if ( !privateCameraView && !IsLocked(idealWeapon) && (!hand.IsValid() || hand->IsLowered()) && !InCinematic() && weapon.IsValid() && g_crosshair.GetInteger() ) {
		weapon->UpdateCrosshairs(combatCrosshair, targeting);
		crosshair = g_crosshair.GetInteger();
	}

	cursor->SetStateBool( "combatcursor", targeting ? false : combatCrosshair );
	cursor->SetStateBool( "activecombatcursor", targeting );
	cursor->SetStateInt( "crosshair", crosshair );
}


/*
================
hhPlayer::UpdateFocus

Searches nearby entities for interactive guis, possibly making one of them
the focus and sending it a mouse move event
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
================
*/
void hhPlayer::UpdateFocus( void ) {
	idClipModel *clipModelList[ MAX_GENTITIES ];
	idClipModel *clip;
	int			listedClipModels;
	idEntity	*oldFocus;
	idEntity	*ent;
	idUserInterface *oldUI;
	int			i, j;
	idVec3		start, end;
	const char *command;
	trace_t		trace;
	guiPoint_t	pt;
	const idKeyValue *kv;
	sysEvent_t	ev;
	idUserInterface *ui;

	if ( gameLocal.inCinematic ) {
		return;
	}

	oldFocus		= focusGUIent;
	oldUI			= focusUI;

	if ( focusTime <= gameLocal.time ) {
		ClearFocus();
	}

	// don't let spectators interact with GUIs
	if ( spectating ) {
		return;
	}

	start = GetEyePosition();

	//HUMANHEAD rww - the actual viewAngles do not seem to be properly transformed to at this point,
	//so just get a transformed direction now.
	idVec3 viewDir = (untransformedViewAngles.ToMat3()*GetEyeAxis())[0];

	end = start + viewDir * 70.0f;	// was 50, doom=80

	// HUMANHEAD pdm: Changed aim logic a bit
	// player identification -> names to the hud
	if ( gameLocal.isMultiplayer && entityNumber == gameLocal.localClientNum ) {
		idVec3 end = start + viewDir * 768.0f;
		gameLocal.clip.TracePoint( trace, start, end, MASK_SHOT_BOUNDINGBOX, this );
		if ( ( trace.fraction < 1.0f ) && ( trace.c.entityNum < MAX_CLIENTS ) ) {
			MPAim = trace.c.entityNum;
		}
		else {
			MPAim = -1;

			//HUMANHEAD rww - if we're hitting a shuttle with a pilot, set the pilot to the MPAim ent
			if (trace.c.entityNum >= MAX_CLIENTS && trace.c.entityNum < MAX_GENTITIES) {
				idEntity *traceEnt = gameLocal.entities[trace.c.entityNum];
				if (traceEnt && traceEnt->IsType(hhVehicle::Type)) { //is it a vehicle?
					hhVehicle *traceVeh = static_cast<hhVehicle *>(traceEnt);
					if (traceVeh->GetPilot() && traceVeh->GetPilot()->IsType(hhPlayer::Type)) { //if it's a vehicle, does it have a player pilot?
						MPAim = traceVeh->GetPilot()->entityNumber;
					}
				}
			}
			//HUMANHEAD END
		}
	}

	idBounds bounds( start );
	bounds.AddPoint( end );

	listedClipModels = gameLocal.clip.ClipModelsTouchingBounds( bounds, -1, clipModelList, MAX_GENTITIES );

	// no pretense at sorting here, just assume that there will only be one active
	// gui within range along the trace
	for ( i = 0; i < listedClipModels; i++ ) {
		clip = clipModelList[ i ];
		ent = clip->GetEntity();

		if ( ent->IsHidden() ) {
			continue;
		}

		// HUMANHEAD pdm: added support here for all guis, not just gui1
		int interactiveMask = 0;
		renderEntity_t *renderEnt = ent->GetRenderEntity();
		if ( renderEnt ) {
			for (int ix=0; ix<MAX_RENDERENTITY_GUI; ix++) {
				if (renderEnt->gui[ix] && renderEnt->gui[ix]->IsInteractive()) {
					interactiveMask |= (1<<ix);
				}
			}
		}
		if (!interactiveMask) {
			continue;
		}

		pt = gameRenderWorld->GuiTrace( ent->GetModelDefHandle(), start, end/*, interactiveMask*/); // jmarshall implement interactiveMask

		if ( ent->fl.accurateGuiTrace ) {
			trace_t tr;
			gameLocal.clip.TracePoint(tr, start, end, CONTENTS_SOLID, this);
			if (tr.fraction < pt.frac) {
				continue;
			}
		}

		if ( pt.x != -1 ) {
			// we have a hit
			renderEntity_t *focusGUIrenderEntity = ent->GetRenderEntity();
			if ( !focusGUIrenderEntity ) {
				continue;
			}

			if ( pt.guiId == 1 ) {
				ui = focusGUIrenderEntity->gui[ 0 ];
			} else if ( pt.guiId == 2 ) {
				ui = focusGUIrenderEntity->gui[ 1 ];
			} else {
				ui = focusGUIrenderEntity->gui[ 2 ];
			}
			
			if ( ui == NULL ) {
				continue;
			}

			ClearFocus();
			focusGUIent = ent;
			focusUI = ui;

			if ( oldFocus != ent ) {
				// new activation
				// going to see if we have anything in inventory a gui might be interested in
				// need to enumerate inventory items
				focusUI->SetStateInt( "inv_count", inventory.items.Num() );
				for ( j = 0; j < inventory.items.Num(); j++ ) {
					idDict *item = inventory.items[ j ];
					const char *iname = item->GetString( "inv_name" );
					const char *iicon = item->GetString( "inv_icon" );
					const char *itext = item->GetString( "inv_text" );

					focusUI->SetStateString( va( "inv_name_%i", j), iname );
					focusUI->SetStateString( va( "inv_icon_%i", j), iicon );
					focusUI->SetStateString( va( "inv_text_%i", j), itext );
					kv = item->MatchPrefix("inv_id", NULL);
					if ( kv ) {
						focusUI->SetStateString( va( "inv_id_%i", j ), kv->GetValue() );
					}
					// HUMANHEAD nla - Changed to pass all "passtogui_" keys to the gui
					kv = item->MatchPrefix("passtogui_", NULL);
					if ( kv ) {
						focusUI->SetStateString( kv->GetKey(), kv->GetValue() );
						kv = item->MatchPrefix( "passtogui_", kv );
					}
					// HUMANHEAD END
					focusUI->SetStateInt( iname, 1 );
				}

				focusUI->SetStateString( "player_health", va("%i", health ) );
				focusUI->SetStateBool( "player_spiritwalking", IsSpiritWalking() );	// for hunterhand gui

				kv = focusGUIent->spawnArgs.MatchPrefix( "gui_parm", NULL );
				while ( kv ) {
					focusUI->SetStateString( kv->GetKey(), kv->GetValue() );
					kv = focusGUIent->spawnArgs.MatchPrefix( "gui_parm", kv );
				}
			}

			// clamp the mouse to the corner
			ev = sys->GenerateMouseMoveEvent( -2000, -2000 );
			command = focusUI->HandleEvent( &ev, gameLocal.time );
 			HandleGuiCommands( focusGUIent, command );

			// move to an absolute position
			ev = sys->GenerateMouseMoveEvent( pt.x * SCREEN_WIDTH, pt.y * SCREEN_HEIGHT );
			command = focusUI->HandleEvent( &ev, gameLocal.time );
			HandleGuiCommands( focusGUIent, command );
			focusTime = gameLocal.time + FOCUS_GUI_TIME;
			break;
		}
	}

	if ( focusGUIent && focusUI ) {
		if ( !oldFocus || oldFocus != focusGUIent ) {
			command = focusUI->Activate( true, gameLocal.time );
			HandleGuiCommands( focusGUIent, command );
			//StartSound( "snd_guienter", SND_CHANNEL_ANY, 0, false, NULL );
		}
	} else if ( oldFocus && oldUI ) {
		command = oldUI->Activate( false, gameLocal.time );
		HandleGuiCommands( oldFocus, command );
		//StartSound( "snd_guiexit", SND_CHANNEL_ANY, 0, false, NULL );
	}
}


/*
===============
hhPlayer::ApplyLandDeflect

HUMANHEAD: aob
===============
*/
idVec3 hhPlayer::ApplyLandDeflect( const idVec3& pos, float scale ) {
	idVec3	localPos( pos );
	int		delta = 0;
	float	fraction = 0.0f;

	// add fall height
	delta = gameLocal.time - landTime;
	if ( delta < LAND_DEFLECT_TIME ) {
		fraction = (float)delta / LAND_DEFLECT_TIME;
		//HUMANHEAD: aob
		fraction *= scale;
		//HUMANHEAD END
		localPos += cameraInterpolator.GetCurrentUpVector() * landChange * fraction;
	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
		fraction = (float)(LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
		//HUMANHEAD: aob
		fraction *= scale;
		//HUMANHEAD END
		localPos += cameraInterpolator.GetCurrentUpVector() * landChange * fraction;
	}

	return localPos;
}

/*
=================
hhPlayer::CrashLand

Check for hard landings that generate sound events
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
=================
*/
void hhPlayer::CrashLand( const idVec3 &oldOrigin, const idVec3 &oldVelocity ) {
	//HUMANHEAD: aob - removed unused vars
	idVec3		origin;
	idVec3		gravityNormal;
	float		delta;
	waterLevel_t waterLevel;
	bool		noDamage;
	//HUMANHEAD END

	//HUMANHEAD: aob
	const trace_t&	trace = physicsObj.GetGroundTrace();
	//HUMANHEAD END

	AI_SOFTLANDING = false;
	AI_HARDLANDING = false;

	//HUMANHEAD: aob - added IsBound and trace check
	// if the player is not on the ground
	if ( (!physicsObj.HasGroundContacts() || trace.fraction == 1.0f) && !IsBound() ) {
		return;
	}

	//HUMANHEAD: aob - only check when we land on the ground
	//If we get here we can assume we currently have ground contacts
	if( physicsObj.HadGroundContacts() ) {
		return;
	}
	//HUMANHEAD END

	gravityNormal = physicsObj.GetGravityNormal();

	// if the player wasn't going down
	if ( ( oldVelocity * -gravityNormal ) >= 0.0f ) {
		return;
	}

	waterLevel = physicsObj.GetWaterLevel();

	// never take falling damage if completely underwater
	if ( waterLevel == WATERLEVEL_HEAD ) {
		return;
	}

	// no falling damage if touching a nodamage surface
	noDamage = false;
	for ( int i = 0; i < physicsObj.GetNumContacts(); i++ ) {
		const contactInfo_t &contact = physicsObj.GetContact( i );
		if ( contact.material->GetSurfaceFlags() & SURF_NODAMAGE ) {
			noDamage = true;
			break;
		}
	}

	//HUMANHEAD: aob - removed velocity calculations

	//HUMANHEAD: aob
	idVec3 deltaVelocity = DetermineDeltaCollisionVelocity( oldVelocity, trace );
	delta = (IsBound()) ? deltaVelocity.Length() : deltaVelocity * gravityNormal;
	//HUMANHEAD END

	// reduce falling damage if there is standing water
	if ( waterLevel == WATERLEVEL_WAIST ) {
		delta *= 0.25f;
	}
	if ( waterLevel == WATERLEVEL_FEET ) {
		delta *= 0.5f;
	}

	if ( delta < crashlandSpeed_jump || IsSpiritOrDeathwalking() ) {
		return;	// Early out
	}

	// Calculate landing sound volume
	float soundScale = hhUtils::CalculateScale( delta, crashlandSpeed_jump, crashlandSpeed_fatal );
	landChange = -32 * soundScale;
	landTime = gameLocal.time;
	float min = hhMath::dB2Scale( spawnArgs.GetInt("minCrashLandVolumedB", "-20") );
	float max = hhMath::dB2Scale( spawnArgs.GetInt("maxCrashLandVolumedB", "-4") );
	soundScale = min + (max - min) * soundScale;

	idVec3		fallDir = oldVelocity;
	idVec3		reverseContactNormal = -physicsObj.GetGroundContactNormal();
	idEntity*	entity = NULL;
	float		damageScale = hhUtils::CalculateScale( delta, crashlandSpeed_soft, crashlandSpeed_fatal );

	fallDir.Normalize();

	if( trace.fraction == 1.0f ) {
		return;
	}
		
	if( !IsBound() ) {
		PlayCrashLandSound( trace, soundScale );
		gameLocal.AlertAI( this, spawnArgs.GetFloat( "land_alert_radius", "400" ) );
	}

	// Determine damage to what you're landing on
	entity = gameLocal.GetTraceEntity( trace );
	if( entity && trace.c.entityNum != ENTITYNUM_WORLD ) {
		entity->ApplyImpulse( this, 0, trace.c.point, (oldVelocity * reverseContactNormal) * reverseContactNormal );//Not sure if this impulse is large enough

		const char* entityDamageName = spawnArgs.GetString( "def_damageFellOnto" );
		if( *entityDamageName && damageScale > 0.0f) {
			entity->Damage( this, this, fallDir, entityDamageName, damageScale, INVALID_JOINT );
		}
	}

	// Calculate damage to self
	const char* selfDamageName = NULL;
	if ( delta < crashlandSpeed_soft ) {			// Soft Fall
		AI_SOFTLANDING = true;
		selfDamageName = spawnArgs.GetString( "def_damageSoftFall" );
	}
	else if ( delta < crashlandSpeed_fatal ) {		// Hard Fall
		AI_HARDLANDING = true;
		selfDamageName = spawnArgs.GetString( "def_damageHardFall" );
	}
	else {											// Fatal Fall
		AI_HARDLANDING = true;
		selfDamageName = spawnArgs.GetString( "def_damageFatalFall" );
	}

	if( *selfDamageName && damageScale > 0.0f && !noDamage ) {
		pain_debounce_time = gameLocal.time + pain_delay + 1;  // ignore pain since we'll play our landing anim
		Damage( NULL, NULL, fallDir, selfDamageName, damageScale, INVALID_JOINT );
	}
}

/*
===============
hhPlayer::ApplyBobCycle

HUMANHEAD: aob
===============
*/
#define BOB_TO_NOBOB_RETURN_TIME 3000.0f
idVec3 hhPlayer::ApplyBobCycle( const idVec3& pos, const idVec3& velocity ) {
	float			delta = 0.0f;
	idVec3			localViewBob( pos );
	const float		maxBob = 6.0f;

	if( bob > 0.0f && !usercmd.forwardmove && !usercmd.rightmove ) {//smoothly goto bob of zero if not already there
		delta = gameLocal.time - lastAppliedBobCycle;
		bob *= ( 1.0f - (delta / BOB_TO_NOBOB_RETURN_TIME) );
		if( bob < 0.0f ) {
			bob = 0.0f;
		}
	} else {
		// add bob height after any movement smoothing
		lastAppliedBobCycle = gameLocal.time;
		bob = bobfracsin * xyspeed * pm_bobup.GetFloat();
		if( bob > maxBob ) {
			bob = maxBob;
		}
	}
	
	localViewBob -= cameraInterpolator.GetCurrentUpVector() * bob;

	return localViewBob;
}


/*
===============
hhPlayer::BobCycle
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::BobCycle( const idVec3 &pushVelocity ) {
	float		bobmove;
	int			old; //, deltaTime;
	idVec3		vel, gravityDir, velocity;
	idMat3		viewaxis;
//	float		bob;
	float		delta;
	float		speed;
//	float		f;

	//
	// calculate speed and cycle to be used for
	// all cyclic walking effects
	//
	velocity = physicsObj.GetLinearVelocity() - pushVelocity;

	//HUMANHEAD: aob - changed GetGravityNormal to GetCurrentUpVector to smooth out wallwalk
	gravityDir = -cameraInterpolator.GetCurrentUpVector();
	//HUMANHEAD END
	vel = velocity - ( velocity * gravityDir ) * gravityDir;
	xyspeed = vel.LengthFast();

	// do not evaluate the bob for other clients
	// when doing a spectate follow, don't do any weapon bobbing
	if ( gameLocal.isClient && entityNumber != gameLocal.localClientNum ) {
		//HUMANHEAD rww - allow bob when following players in spectator mode
		bool canBob = false;
		if (gameLocal.localClientNum != -1 && gameLocal.entities[gameLocal.localClientNum] && gameLocal.entities[gameLocal.localClientNum]->IsType(hhPlayer::Type)) {
			hhPlayer *pl = static_cast<hhPlayer *>(gameLocal.entities[gameLocal.localClientNum]);
			if (pl->spectating && pl->spectator == entityNumber) {
				canBob = true;
			}
		}

		if (!canBob) {
		//HUMANHEAD END
			viewBobAngles.Zero();
			viewBob.Zero();
			return;
		}
	}

	if ( !physicsObj.HasGroundContacts() || influenceActive == INFLUENCE_LEVEL2 || ( gameLocal.isMultiplayer && spectating ) ) {
		// airborne
		bobCycle = 0;
		bobFoot = 0;
		bobfracsin = 0;
	} else if ( ( !usercmd.forwardmove && !usercmd.rightmove ) || ( xyspeed <= MIN_BOB_SPEED ) ) {
		// start at beginning of cycle again
		bobCycle = 0;
		bobFoot = 0;
		bobfracsin = 0;
	} else {
		if ( physicsObj.IsCrouching() ) {
			bobmove = pm_crouchbob.GetFloat();
			// ducked characters never play footsteps
		} else {
			// vary the bobbing based on the speed of the player
			bobmove = pm_walkbob.GetFloat() * ( 1.0f - bobFrac ) + pm_runbob.GetFloat() * bobFrac;	
		}

		// check for footstep / splash sounds
		old = bobCycle;
		bobCycle = (int)( old + bobmove * gameLocal.msec ) & 255;
		bobFoot = ( bobCycle & 128 ) >> 7;
		bobfracsin = idMath::Fabs( sin( ( bobCycle & 127 ) / 127.0 * idMath::PI ) );
	}

	// calculate angles for view bobbing
	viewBobAngles.Zero();

	viewaxis = viewAngles.ToMat3();

	// add angles based on velocity
	delta = velocity * viewaxis[0];
	viewBobAngles.pitch += delta * pm_runpitch.GetFloat();
	
	delta = velocity * viewaxis[1];
	viewBobAngles.roll -= delta * pm_runroll.GetFloat();

	// add angles based on bob
	// make sure the bob is visible even at low speeds
	speed = xyspeed > 200 ? xyspeed : 200;

	delta = bobfracsin * pm_bobpitch.GetFloat() * speed;
	if ( physicsObj.IsCrouching() ) {
		delta *= 3;		// crouching
	}
	viewBobAngles.pitch += delta;
	delta = bobfracsin * pm_bobroll.GetFloat() * speed;
	if ( physicsObj.IsCrouching() ) {
		delta *= 3;		// crouching accentuates roll
	}
	if ( bobFoot & 1 ) {
		delta = -delta;
	}
	viewBobAngles.roll += delta;

	//HUMANHEAD: aob
#if HUMANHEAD
	viewBob = ApplyBobCycle( ApplyLandDeflect(vec3_zero, 1.0f), velocity );
#else
	// calculate position for view bobbing
	viewBob.Zero();

	if ( physicsObj.HasSteppedUp() ) {

		// check for stepping up before a previous step is completed
		deltaTime = gameLocal.time - stepUpTime;
		if ( deltaTime < STEPUP_TIME ) {
			stepUpDelta = stepUpDelta * ( STEPUP_TIME - deltaTime ) / STEPUP_TIME + physicsObj.GetStepUp();
		} else {
			stepUpDelta = physicsObj.GetStepUp();
		}
		if ( stepUpDelta > 2.0f * pm_stepsize.GetFloat() ) {
			stepUpDelta = 2.0f * pm_stepsize.GetFloat();
		}
		stepUpTime = gameLocal.time;
	}

	idVec3 gravity = physicsObj.GetGravityNormal();

	// if the player stepped up recently
	deltaTime = gameLocal.time - stepUpTime;
	if ( deltaTime < STEPUP_TIME ) {
		viewBob += gravity * ( stepUpDelta * ( STEPUP_TIME - deltaTime ) / STEPUP_TIME );
	}

	// add bob height after any movement smoothing
	bob = bobfracsin * xyspeed * pm_bobup.GetFloat();
	if ( bob > 6 ) {
		bob = 6;
	}
	viewBob[2] += bob;

	// add fall height
	delta = gameLocal.time - landTime;
	if ( delta < LAND_DEFLECT_TIME ) {
		f = delta / LAND_DEFLECT_TIME;
		viewBob -= gravity * ( landChange * f );
	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
		delta -= LAND_DEFLECT_TIME;
		f = 1.0 - ( delta / LAND_RETURN_TIME );
		viewBob -= gravity * ( landChange * f );
	}
#endif	//HUMANHEAD END
}

/*
================
hhPlayer::UpdateDeltaViewAngles
================
*/
void hhPlayer::UpdateDeltaViewAngles( const idAngles &angles ) {
	// set the delta angle
	idAngles delta;
	for( int i = 0; i < 3; i++ ) {
#if 1 //rww - revert to id's method
		//delta[i] = ((angles[i] - GetUntransformedViewAngles()[i]) / GetViewAnglesSensitivity()) + GetUntransformedViewAngles()[i] - SHORT2ANGLE(usercmd.angles[i]);
		delta[ i ] = angles[ i ] - SHORT2ANGLE( usercmd.angles[ i ] );
#else // HUMANHEAD mdl:  If you enable this, comment out the SetOrientation() call for vehicles in hhPlayer::Restore()
		delta[i] = (angles[i] - idMath::AngleNormalize180( SHORT2ANGLE(usercmd.angles[ i ]) - oldCmdAngles[i]) * GetViewAnglesSensitivity());
#endif
	}
	SetDeltaViewAngles( delta );
}

/*
================
hhPlayer::DetermineViewAngles
================
*/
idAngles hhPlayer::DetermineViewAngles( const usercmd_t& cmd, idAngles& cmdAngles ) {
	int i;
	idAngles localViewAngles( GetUntransformedViewAngles() );
	idAngles deltaCmdAngles;

	if ( !noclip && ( gameLocal.inCinematic || privateCameraView || gameLocal.GetCamera() || influenceActive == INFLUENCE_LEVEL2 ) ) {
		// no view changes at all, but we still want to update the deltas or else when
		// we get out of this mode, our view will snap to a kind of random angle
		return GetUntransformedViewAngles();
	}

	//HUMANHEAD rww - testing
	/*
	if (gameLoacl.isClient && gameLocal.localClientNum != entityNumber) {
		idQuat a = viewAngles.ToQuat();
		idQuat b = GetUntransformedViewAngles().ToQuat();
		idQuat c;
		c.Slerp(a, b, 0.3f);
		return c.ToAngles();
	}
	*/
	//HUMANHEAD END

	// if dead
	if ( IsDead() ) {
#if 0
		if ( DoThirdPersonDeath() ) {
			localViewAngles.roll = 0.0f;
			localViewAngles.pitch = 30.0f;
		}
		else {
			localViewAngles.roll = 40.0f;
			localViewAngles.pitch = -15.0f;
		}
		return localViewAngles;
#else //HUMANHEAD PCF rww 04/26/06 - look freely while dead in MP
		if ( !DoThirdPersonDeath() ) {
			localViewAngles.roll = 40.0f;
			localViewAngles.pitch = -15.0f;
			return localViewAngles;
		}
#endif //HUMANHEAD END
	}

	//JSHTODO this messes up multiplayer input.  remerge sensitivity code
	// circularly clamp the angles with deltas
	if ( usercmd.buttons & BUTTON_MLOOK ) {
		for ( i = 0; i < 3; i++ ) {
			cmdAngles[i] = SHORT2ANGLE( usercmd.angles[i] );
#if 1 //rww - revert to id's method
			//localViewAngles[i] = idMath::AngleNormalize180( cmdAngles[i] + deltaViewAngles[i] - GetUntransformedViewAngles()[i] ) * GetViewAnglesSensitivity() + GetUntransformedViewAngles()[i];
			localViewAngles[i] = idMath::AngleNormalize180( SHORT2ANGLE( usercmd.angles[i]) + deltaViewAngles[i] );
#else
			deltaCmdAngles[i] = idMath::AngleNormalize180( cmdAngles[i] - oldCmdAngles[i] ) * GetViewAnglesSensitivity();
			oldCmdAngles[i] = cmdAngles[i];
			localViewAngles[i] = deltaCmdAngles[i] + deltaViewAngles[i];
#endif
		}
	} else {
#if 1 //rww - revert to id's method
		//localViewAngles.yaw = idMath::AngleNormalize180( SHORT2ANGLE( usercmd.angles[YAW] ) + deltaViewAngles[YAW] - GetUntransformedViewAngles()[YAW] ) * GetViewAnglesSensitivity() + GetUntransformedViewAngles()[YAW];
		localViewAngles.yaw = idMath::AngleNormalize180( SHORT2ANGLE( usercmd.angles[YAW]) + deltaViewAngles[YAW] );
#if GAMEPAD_SUPPORT	// VENOM BEGIN
		oldCmdAngles[YAW] = SHORT2ANGLE( usercmd.angles[YAW] );
#endif // VENOM END
#else
		deltaCmdAngles[YAW] = idMath::AngleNormalize180( SHORT2ANGLE(usercmd.angles[YAW]) - oldCmdAngles[YAW] ) * GetViewAnglesSensitivity();
		oldCmdAngles[YAW] = SHORT2ANGLE( usercmd.angles[YAW] );
		localViewAngles.yaw = deltaCmdAngles[YAW] + deltaViewAngles[YAW];
#endif

		if (!centerView.IsDone(gameLocal.time)) {
			localViewAngles.pitch = centerView.GetCurrentValue(gameLocal.time);
		}
	}

#if GAMEPAD_SUPPORT	// VENOM BEGIN
	float fpitch = idMath::Fabs(localViewAngles.pitch);
	if( idMath::Abs(usercmd.rightmove) < 10 && 
		idMath::Abs(usercmd.forwardmove) > 80  && 
		fpitch > 1.f  && 
		idMath::Fabs(oldCmdAngles[YAW] - cmdAngles[YAW]) < 1.0f && 
		idMath::Fabs(oldCmdAngles[PITCH] - cmdAngles[PITCH]) < 1.0f
	)
	{
		// dont start the leveling until we have .5 sec of valid movement
		if((gameLocal.time - lastAutoLevelTime) > 500 ) {
			float fadd = 0.6f;
			if(fpitch < 10.f) {
				fadd *= (fpitch/10.f );
				fadd+= 0.05f;
			}
			
			if(localViewAngles.pitch < 0 ) {
				localViewAngles.pitch +=fadd;
			}
			else {
				localViewAngles.pitch -=fadd;
			}
		}
	}
	else {
		lastAutoLevelTime = gameLocal.time;
	}

	oldCmdAngles[YAW]	= cmdAngles[YAW];
	oldCmdAngles[PITCH] = cmdAngles[PITCH];
#endif // VENOM END

	// clamp the pitch
	if ( noclip ) {
		localViewAngles.pitch = hhMath::ClampFloat( -89.0f, 89.0f, localViewAngles.pitch );
	} else {
		//HUMANHEAD PCF rww 04/26/06 - look freely while dead in MP
		if (IsDead() && DoThirdPersonDeath()) {
			localViewAngles.pitch = hhMath::ClampFloat( -45.0f, 45.0f, localViewAngles.pitch );
		}
		else {
		//HUMANHEAD END
			localViewAngles.pitch = hhMath::ClampFloat( pm_minviewpitch.GetFloat(), pm_maxviewpitch.GetFloat(), localViewAngles.pitch );
		}
	}

	// HUMANHEAD pdm: clamp the yaw (only used for bindControllers)
	if ( !noclip && bClampYaw ) {
		float idealYaw=0.0f;
		idVec3 masterOrigin;
		idMat3 masterAxis;

		if (GetMasterPosition(masterOrigin, masterAxis)) {
			idealYaw = masterAxis[0].ToYaw();
			idealYaw = idMath::AngleNormalize180( idealYaw );
		}

		// Transpose the everything to "zero" space before clamping, so idealYaw is at zero in a (-180..180) normalized space
		float zeroSpaceYaw = idMath::AngleNormalize180( localViewAngles.yaw - idealYaw );
		zeroSpaceYaw = idMath::ClampFloat(-maxRelativeYaw, maxRelativeYaw, zeroSpaceYaw);
		localViewAngles.yaw = idMath::AngleNormalize180( zeroSpaceYaw + idealYaw );
	}
	// HUMANHEAD END

	UpdateDeltaViewAngles( localViewAngles );

	// save in the log for analyzing weapon angle offsets
	loggedViewAngles[ gameLocal.framenum & (NUM_LOGGED_VIEW_ANGLES-1) ] = localViewAngles;

	return localViewAngles;
}

/*
================
hhPlayer::SetViewAnglesSensitivity
================
*/
void hhPlayer::SetViewAnglesSensitivity( float factor ) {
	viewAnglesSensitivity = factor;
	if (gameLocal.localClientNum == entityNumber) {
		//common->SetGameSensitivityFactor(factor); // jmarshall
	}
}

/*
================
hhPlayer::GetViewAnglesSensitivity
================
*/
float hhPlayer::GetViewAnglesSensitivity() const {
	return viewAnglesSensitivity;
}

/*
================
hhPlayer::UpdateViewAngles
================
*/
void hhPlayer::UpdateViewAngles( void ) {
	if( InVehicle() ) {
		return;
	}

	if (!noclip && (InCinematic() && lockView)) {
		// no view changes at all, but we still want to update the deltas or else when
		// we get out of this mode, our view will snap to a kind of random angle
		UpdateDeltaViewAngles( viewAngles );
		return;
	}

	//HUMANHEAD: aob - moved logic into helper function so we can call this somewhere else while in a vehicle
	viewAngles = DetermineViewAngles( usercmd, cmdAngles );

	//HUMANHEAD rww - moved angle smoothing code here
	// update the smoothed view angles
	if (gameLocal.isClient) {
		if ( gameLocal.framenum >= smoothedFrame && entityNumber != gameLocal.localClientNum ) {
			idAngles anglesDiff = viewAngles - smoothedAngles;
			anglesDiff.Normalize180();
			if ( idMath::Fabs( anglesDiff.yaw ) < 90.0f && idMath::Fabs( anglesDiff.pitch ) < 90.0f ) {
				// smoothen by pushing back to the previous angles
				viewAngles -= gameLocal.clientSmoothing * anglesDiff;
				viewAngles.Normalize180();
			}
			smoothedAngles = viewAngles;
		}
		smoothedOriginUpdated = false;
	}

	// orient the model towards the direction we're looking
	UpdateOrientation( viewAngles );
	//HUMANHEAD END
}

/*
=====================
hhPlayer::UpdateOrientation

HUMANHEAD: aob
=====================
*/
void hhPlayer::UpdateOrientation( const idAngles& newUntransformedViewAngles ) {
	idAngles angles;
	//This is where the camera interpolator transforms the viewAngles to work with wallwalk.
	//We also store the original untransformed view angles for use in some other code.
	//idPlayer called SetAxis, but only used the yaw but because we are transforming our view angles
	//we do something similier by taking the untransformed yaw and rotating by the camera interpolator's axis.
	//This becomes our new axis, the camera interpolator axis plus the untransformed view angles yaw
	SetUntransformedViewAngles( newUntransformedViewAngles );

	angles = GetUntransformedViewAngles();
	if( IsWallWalking() ) {
		angles.pitch = 0.0f;
	}
	SetUntransformedViewAxis( idAngles( 0.0f, angles.yaw, 0.0f ).ToMat3() );

	viewAngles = cameraInterpolator.UpdateViewAngles( angles );
	SetAxis( TransformToPlayerSpace(GetUntransformedViewAxis()) );
}

//=============================================================================
//
// hhPlayer::CheckFOV
//
// Similar to idActor::CheckFOV, but isn't infinite along the vertical plane
//
// CJR
//=============================================================================

bool hhPlayer::CheckFOV( const idVec3 &pos ) {
	if ( fovDot == 1.0f ) {
		return true;
	}

	float	dot;
	idVec3	delta;
	
	delta = pos - GetEyePosition();
	delta.Normalize();

	dot = delta * viewAngles.ToForward();

	return ( dot >= fovDot );
}

//=============================================================================
// hhPlayer::CheckFOV
// jsh - Similar to CheckFOV, but only checks yaw
//=============================================================================
bool hhPlayer::CheckYawFOV( const idVec3 &pos ) {
	if ( fovDot == 1.0f ) {
		return true;
	}

	float	dot;
	idVec3	delta;
	idVec3	viewAng;

	delta = pos - GetEyePosition();
	delta.z = 0;
	delta.Normalize();
	viewAng = viewAngles.ToForward();
	viewAng.z = 0;
	dot = delta * viewAng;

	return ( dot >= fovDot );
}


/*
=====================
hhPlayer::SetOrientation

HUMANHEAD: aob
=====================
*/
void hhPlayer::SetOrientation( const idVec3& origin, const idMat3& bboxAxis, const idVec3& lookDir, const idAngles& newUntransformedViewAngles ) {
	//never let the untransformed view angles have a roll value
	idAngles modifiedUntransViewAngles = newUntransformedViewAngles;
	modifiedUntransViewAngles.roll = 0.0f;

	physicsObj.SetOrigin( GetLocalCoordinates(origin) );
	physicsObj.SetAxis( bboxAxis );
	physicsObj.CheckWallWalk( true );

	SetViewAngles( modifiedUntransViewAngles );
	BufferLoggedViewAngles( modifiedUntransViewAngles );
	SetUntransformedViewAngles( modifiedUntransViewAngles );

	SetAxis( lookDir.ToMat3() );
	SetUntransformedViewAxis( idAngles(0.0f, modifiedUntransViewAngles.yaw, 0.0f).ToMat3() );

	cameraInterpolator.Reset( origin, bboxAxis[2], EyeHeightIdeal() );
	
	UpdateViewAngles();
	UpdateVisuals();
}
/*
=====================
hhPlayer::RestoreOrientation

HUMANHEAD: mdl
Same as SetOrientation, except doesn't check wallwalk, since the materials may not be set before the first frame.
=====================
*/
void hhPlayer::RestoreOrientation( const idVec3& origin, const idMat3& bboxAxis, const idVec3& lookDir, const idAngles& newUntransformedViewAngles ) {
	physicsObj.SetOrigin( GetLocalCoordinates(origin) );
	physicsObj.SetAxis( bboxAxis );

	SetViewAngles( newUntransformedViewAngles );
	BufferLoggedViewAngles( newUntransformedViewAngles );
	SetUntransformedViewAngles( newUntransformedViewAngles );

	SetAxis( lookDir.ToMat3() );
	SetUntransformedViewAxis( idAngles(0.0f, newUntransformedViewAngles.yaw, 0.0f).ToMat3() );
	cameraInterpolator.Reset( origin, bboxAxis[2], EyeHeightIdeal() );
	
	UpdateViewAngles();
	UpdateVisuals();
}

/*
=====================
hhPlayer::BufferLoggedViewAngles

HUMANHEAD: aob - used when teleporting and using portals
=====================
*/
void hhPlayer::BufferLoggedViewAngles( const idAngles& newUntransformedViewAngles ) {
	idAngles deltaAngles = newUntransformedViewAngles - GetUntransformedViewAngles();

	for( int ix = 0; ix < NUM_LOGGED_VIEW_ANGLES; ++ix ) {
		loggedViewAngles[ix] += deltaAngles;
	}
}

/*
================
hhPlayer::UpdateFromPhysics

AOBMERGE - PERSISTANT MERGE
================
*/
void hhPlayer::UpdateFromPhysics( bool moveBack ) {

	// set master delta angles for actors
	if ( GetBindMaster() ) {
		if( !InVehicle() ) {
			idAngles delta = GetDeltaViewAngles();
			if ( moveBack ) {
				delta.yaw -= physicsObj.GetMasterDeltaYaw();
			} else {
				delta.yaw += physicsObj.GetMasterDeltaYaw();
			}
		
			SetDeltaViewAngles( delta );
		} else {
			SetUntransformedViewAxis( mat3_identity );
			SetUntransformedViewAngles( GetUntransformedViewAxis().ToAngles() );
			viewAngles = GetUntransformedViewAngles();
			SetAxis( GetBindMaster()->GetAxis() );

			//AOB - now that we have an updated viewAxis we need to update the 
			//camera.  Feels like a hack!
			cameraInterpolator.SetTargetAxis( GetAxis(), INTERPOLATE_NONE );
		}
	}

	UpdateVisuals();
}

/*
==============
hhPlayer::PerformImpulse
==============
*/

void hhPlayer::PerformImpulse( int impulse ) {
	if( InVehicle() && GetVehicleInterface()->InvalidVehicleImpulse(impulse) ) {
		return;
	}

	idPlayer::PerformImpulse( impulse );

	switch( impulse ) {
		case IMPULSE_14: {
			if ( weapon.IsValid() && weapon->IsType( hhWeaponZoomable::Type ) ) {
				hhWeaponZoomable *weap = static_cast<hhWeaponZoomable*>(weapon.GetEntity());
				if ( weap && weap->GetAltMode() ) {
					weap->ZoomInStep();
				} else {
					NextWeapon();
				}
			} else {
				NextWeapon();
			}
			break;
		}
		case IMPULSE_15: {
			if ( weapon.IsValid() && weapon->IsType( hhWeaponZoomable::Type ) ) {
				hhWeaponZoomable *weap = static_cast<hhWeaponZoomable*>(weapon.GetEntity());
				if ( weap && weap->GetAltMode() ) {
					weap->ZoomOutStep();
				} else {
					PrevWeapon();
				}
			} else {
				PrevWeapon();
			}
			break;
		}
		case IMPULSE_16:
			// Toggle Lighter
			if (inventory.requirements.bCanUseLighter && weaponFlags != 0) { // mdl:  Disable lighter if all weapons are disabled
				if (!gameLocal.isClient) {
					ToggleLighter();
				}
			}
			break;
		case IMPULSE_25:
			// Throw grenade
			if ( weaponFlags != 0 && !ActiveGui()) { // mdl:  Disable if all weapons are disabled
				if (!gameLocal.isClient) {
					ThrowGrenade();
				}
			}
			break;
		case IMPULSE_54:
			// Spirit Power key
			if ( IsDeathWalking() ) { // CJR:  Developer-only ability to quickly return from DeathWalk by hitting the spirit key
				if ( developer.GetBool() && ( gameLocal.time - deathWalkTime > spawnArgs.GetInt( "deathWalkMinTime", "4000" ) ) ) { // Force the player to stay in deathwalk for a short period of time
					deathWalkFlash = 0.0f;
					PostEventMS( &EV_PrepareToResurrect, 0 );
				}
			}
			else if (inventory.requirements.bCanSpiritWalk) {
				ToggleSpiritWalk();
			}
			break;

		case IMPULSE_18: {
#if GAMEPAD_SUPPORT	// VENOM BEGIN
			idAngles localViewAngles( GetUntransformedViewAngles() );
			centerView.Init(gameLocal.time, 360, localViewAngles.pitch, 0);
#else
			centerView.Init(gameLocal.time, 200, viewAngles.pitch, 0);
#endif // VENOM END
			break;
		}
	}
}

void hhPlayer::Present() {
	idPlayer::Present();

	if ( lighterHandle != -1 ) {
		// Update oscillation position
		idVec3 oscillation;
		oscillation.x = 0.0f;
		oscillation.y = idMath::Cos( MS2SEC(gameLocal.time) * spawnArgs.GetFloat("lighter_yspeed") ) * spawnArgs.GetFloat("lighter_ysize");
		oscillation.z = idMath::Sin( MS2SEC(gameLocal.time) * spawnArgs.GetFloat("lighter_zspeed") ) * spawnArgs.GetFloat("lighter_zsize");

		idVec3 offset;
		offset = spawnArgs.GetVector("offset_lighter");
		offset.z = EyeHeight();
		lighter.origin = GetOrigin() + GetAxis() * (offset + oscillation);
		lighter.axis = mat3_identity;

		lighter.shaderParms[ SHADERPARM_DIVERSITY ]		= renderEntity.shaderParms[ SHADERPARM_DIVERSITY ];

		gameRenderWorld->UpdateLightDef( lighterHandle, &lighter );
	}
}

void hhPlayer::LighterOn() {
	if (IsSpiritOrDeathwalking() || InVehicle() || spectating || bReallyDead) { // No lighter in spirit mode, deathwalk, or when in vehicles (or when spectating or really dead -rww)
		return;
	}

	if (lighterHandle == -1) {
		// Add the dynamic light
		memset( &lighter, 0, sizeof( lighter ) );
		lighter.lightId = LIGHTID_VIEW_MUZZLE_FLASH + entityNumber;
		lighter.pointLight								= true; // false; ?
		lighter.shader									= declManager->FindMaterial( spawnArgs.GetString( "mtr_lighter" ) );
		lighter.shaderParms[ SHADERPARM_RED ]			= spawnArgs.GetFloat( "lighterColorR" );
		lighter.shaderParms[ SHADERPARM_GREEN ]			= spawnArgs.GetFloat( "lighterColorG" );
		lighter.shaderParms[ SHADERPARM_BLUE ]			= spawnArgs.GetFloat( "lighterColorB" );
		lighter.shaderParms[ SHADERPARM_ALPHA ]			= 1.0f;
		lighter.shaderParms[ SHADERPARM_TIMEOFFSET ]	= -MS2SEC( gameLocal.time );
		lighter.lightRadius								= spawnArgs.GetVector( "lighter_radius" );

		lighter.origin = GetOrigin() + GetAxis() * spawnArgs.GetVector("offset_lighter");
		lighter.axis = mat3_identity;

		lighterHandle = gameRenderWorld->AddLightDef( &lighter );

		StartSound("snd_lighter_on", SND_CHANNEL_ITEM);
	}
}

void hhPlayer::LighterOff() {
	if (lighterHandle != -1) {
		gameRenderWorld->FreeLightDef( lighterHandle );
		lighterHandle = -1;
		StartSound("snd_lighter_off", SND_CHANNEL_ITEM);
	}
}

bool hhPlayer::IsLighterOn() const { 	//HUMANHEAD PCF mdl 05/04/06 - Made const
	return (lighterHandle != -1);
}

void hhPlayer::ToggleLighter() {
	if (IsLighterOn()) {
		LighterOff();
	}
	else {
		LighterOn();
	}
}

void hhPlayer::UpdateLighter() {
	if (IsLighterOn()) {
		// Increase the lighter's temperature until it overheats
		if (!gameLocal.isMultiplayer) { //rww - don't bother overheating the lighter in mp
			lighterTemperature += spawnArgs.GetFloat( "lighterHeatRate", "0.025" ) * MS2SEC( USERCMD_MSEC );
			if (lighterTemperature >= 1.0f) {
				// Too hot, turn the lighter off
				StartSound("snd_lighter_toohot", SND_CHANNEL_ANY);
				lighterTemperature = 1.0f;

				if (!(godmode || noclip)) {
					LighterOff();
				}
			}
		}
	}
	else {
		// Lighter is off, so decrease the lighter's temperature
		if (lighterTemperature > 0) {
			lighterTemperature -= spawnArgs.GetFloat( "lighterCoolRate", "0.05")  * MS2SEC( USERCMD_MSEC );
		}
	}
}

/*
==================
hhPlayer::PlayFootstepSound
==================
*/
void hhPlayer::PlayFootstepSound() {
	if ( IsSpiritOrDeathwalking() ) {
		return; // No footstep sounds in spiritwalk mode
	}

	if ( IsWallWalking() ) {
		// Special case wallwalk since contacts includes some non-wallwalk types
		const char* soundKey = gameLocal.MatterTypeToMatterKey( "snd_footstep", SURFTYPE_WALLWALK );
		StartSound( soundKey, SND_CHANNEL_BODY3, 0, false, NULL );
		return;
	}

	idPlayer::PlayFootstepSound();
}

/*
=====================
hhPlayer::PlayPainSound

HUMANHEAD: aob
=====================
*/
void hhPlayer::PlayPainSound() {
	if( IsSpiritOrDeathwalking() ) {
		return;
	}
	
	//HUMANHEAD PCF rww 09/15/06 - female mp sounds
	if (IsFemale()) {
		StartSound( "snd_pain_small_female", SND_CHANNEL_VOICE );
		return;
	}
	//HUMANHEAD END
	idPlayer::PlayPainSound();
}

/*
===============
hhPlayer::Give
===============
*/
bool hhPlayer::Give( const char *statname, const char *value ) {
	if( IsDead() ) {
		return false;
	}

	return inventory.Give( this, spawnArgs, statname, value, &idealWeapon, true );
}

/*
===============
hhPlayer::ReportAttack
===============
*/
void hhPlayer::ReportAttack(idEntity *attacker) {
	if (gameLocal.isServer && attacker) { //rww - broadcast event for this on the server
		idBitMsg	msg;
		byte		msgBuf[MAX_EVENT_PARAM_SIZE];

		msg.Init(msgBuf, sizeof(msgBuf));
		msg.WriteBits(gameLocal.GetSpawnId(attacker), 32);
		//unreliable since it's not super-important, and only send to this player.
		ServerSendEvent(EVENT_REPORTATTACK, &msg, false, -1, entityNumber, true);
	}

	int ix;

	for (ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {

		// If the attacker already exists, stomp it
		if (lastAttackers[ix].attacker == attacker) {
			lastAttackers[ix].time = gameLocal.time;
			lastAttackers[ix].displayed = false;
			return;
		}

		// If any are expired, free their slot
		if (gameLocal.time > lastAttackers[ix].time + DAMAGE_INDICATOR_TIME) {
			lastAttackers[ix].attacker = NULL;
		}
	}

	// Add this attacker to first free slot, if any
	for (ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		if (!lastAttackers[ix].attacker.IsValid()) {
			lastAttackers[ix].attacker = attacker;
			lastAttackers[ix].time = gameLocal.time;
			lastAttackers[ix].displayed = false;
			return;
		}
	}

	// All slots full, overwrite the oldest slot
	int oldSlot = -1;
	int oldTime = gameLocal.time;
	for (ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		if (lastAttackers[ix].time < oldTime) {
			oldTime = lastAttackers[ix].time;
			oldSlot = ix;
		}
	}
	if (oldSlot > 0) {
		lastAttackers[oldSlot].attacker = attacker;
		lastAttackers[oldSlot].time = gameLocal.time;
		lastAttackers[oldSlot].displayed = false;
	}
}

/*
==================
hhPlayer::Damage
==================
*/
void hhPlayer::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir,
					   const char *damageDefName, const float damageScale, const int location ) {

	if(	IsSpiritOrDeathwalking() ) { //Player is spirit-walking, so check for special immunities
		const idKeyValue *kv = spawnArgs.MatchPrefix("immunityspirit");
		while( kv && kv->GetValue().Length() ) {
			if ( !kv->GetValue().Icmp(damageDefName) ) {
				return;
			}
			kv = spawnArgs.MatchPrefix("immunityspirit", kv);
		}

		// If the player is spiritwalking, then any damage takes away spirit power instead of health
		ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName( "ammo_spiritpower" );
		if ( IsSpiritWalking() ) {
			const idDict *damageDef = gameLocal.FindEntityDefDict( damageDefName );
			if ( damageDef ) {
				idPlayer *player = (attacker && attacker->IsType( idPlayer::Type )) ? static_cast<idPlayer*>(attacker) : NULL;
				if ( !(gameLocal.gameType == GAME_TDM
					&& !gameLocal.serverInfo.GetBool( "si_teamDamage" )
					&& !damageDef->GetBool( "noTeam" )
					&& player
					&& player != this		// you get self damage no matter what
					&& player->team == team) ) {
					//rww - don't damage teammates' spirit when ff off
					int damageWhenSpirit = damageDef->GetInt("damageWhenSpirit", "0"); //rww - special damage for knocking players back to body in mp when shot by other things (namely spirit arrows)
					int oldSpirit = inventory.ammo[ ammo_spiritpower ];

					int spiritDamage = (damageDef->GetInt( "damage", "1" ) * spawnArgs.GetFloat( "damageScaleInSpirit" ) * damageScale )+damageWhenSpirit;
					if ( spiritDamage <= 0 && damageScale > 0 ) {
						spiritDamage = 1;
					}

					if ( !UseAmmo( ammo_spiritpower, spiritDamage ) ) {
						inventory.ammo[ ammo_spiritpower ] = 0; // Clear spiritpower amount when returning from excessive damage
					}
				}
			}

			lastDamagedTime = gameLocal.time; // Save the damage time for the health recharge code

			// Track last attacker for use in displaying HUD hit indicator
			if (!gameLocal.isClient) {
				ReportAttack(attacker);
			}

			//HUMANHEAD rww - damage feedback for hitting spirit players in mp
			if (gameLocal.isMultiplayer && attacker && !gameLocal.isClient) {
				hhPlayer *killer = NULL;
				if (attacker->IsType(idPlayer::Type)) {
					killer = static_cast<hhPlayer*>(attacker);
				}
				else if (attacker->IsType(hhVehicle::Type)) {
					hhVehicle *veh = static_cast<hhVehicle*>(attacker);
					if (veh->GetPilot() && veh->GetPilot()->IsType(idPlayer::Type)) {
						killer = static_cast<hhPlayer*>(veh->GetPilot());
					}
				}

				if (killer && killer->entityNumber != entityNumber && killer->mpHitFeedbackTime <= gameLocal.time) {
					if (killer == gameLocal.GetLocalPlayer()) {
						assert(IsSpiritOrDeathwalking());
						if (gameLocal.gameType == GAME_TDM && team == killer->team) {
							killer->StartSound( "snd_hitTeamFeedback", SND_CHANNEL_ITEM, 0, false, NULL );
						}
						else {
							killer->StartSound( "snd_hitSpiritFeedback", SND_CHANNEL_ITEM, 0, false, NULL );

							//hardcoded health ranges for the various flash colors
							float h;
							if (health > 100) {
								h = 0.0f;
							}
							else if (health > 75) {
								h = 0.25f;
							}
							else if (health > 25) {
								h = 0.50f;
							}
							else {
								h = 0.75f;
							}
							SetShaderParm(3, h);
							SetShaderParm(5, -MS2SEC(gameLocal.time)*2);
						}
					}
					else {
						idBitMsg	msg;
						byte		msgBuf[MAX_EVENT_PARAM_SIZE];

						msg.Init(msgBuf, sizeof(msgBuf));
						msg.WriteBits(gameLocal.GetSpawnId(this), 32);
						killer->ServerSendEvent(EVENT_HITNOTIFICATION, &msg, false, -1, killer->entityNumber);
					}
				}
			}
			//HUMANHEAD END

			return;
		}
	}

	lastDamagedTime = gameLocal.time; // Save the damage time for the health recharge code

	// Track last attacker for use in displaying HUD hit indicator
	if (!gameLocal.isClient) {
		ReportAttack(attacker);
	}

	// Check if the damage should "really kill" the player (when in deathwalk mode)
	if ( IsDeathWalking() ) {
		const idDict *damageDef = gameLocal.FindEntityDefDict( damageDefName );
		if ( damageDef ) {
			if ( damageDef->GetBool( "reallyKill", "0" ) ) { // Truly kill the player
				ReallyKilled( inflictor, attacker, damageDef->GetInt( "damage", "9999" ), dir, location );
				return;
			} else if ( damageDef->GetBool( "spiritDamage", "0" ) ) { // Drain spirit power
				ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName( "ammo_spiritpower" );
				UseAmmo( ammo_spiritpower, damageDef->GetInt( "damage", "1" ) * damageScale );
				return;
			}
		}
	}

	//HUMANHEAD rww - keep track of last person to attack me, debounce time will vary based on ground contact
	if (attacker && attacker->IsType(idPlayer::Type)) {
		airAttacker = attacker;
		if (!AI_ONGROUND) {
			airAttackerTime = gameLocal.time + 300;
		}
		else { //if they are on the ground do a 100ms debounce in case they fall off a ledge or something as a result of leftover attack velocity
			airAttackerTime = gameLocal.time + 100;
		}
	}
	//HUMANHEAD END

	// CJR: DDA:  Only in single player
	if ( !gameLocal.isMultiplayer ) {
		float newDamageScale = gameLocal.GetDDAValue() * 2.0f; // Scale damage from easy to hard
		newDamageScale *= damageScale;

		const idDict *damageDef = gameLocal.FindEntityDefDict( damageDefName );
		if ( damageDef ) {
			bool noGod = damageDef->GetBool("noGod", "0");
			if ( noGod ) {
				// Make sure fatal damage bypasses post-deathwalk invulnerability
				fl.takedamage = true;
			}
		}

		int oldHealth = health;
		idPlayer::Damage( inflictor, attacker, dir, damageDefName, (const float)newDamageScale, location ); // CJR DDA TEST

		if ( attacker && attacker->IsType( hhMonsterAI::Type ) ) { // CJR DDA: Damaged by a monster, add the damage to the monster count
			float delta = oldHealth - health;

			hhMonsterAI *monster = static_cast<hhMonsterAI *>( attacker );
			
			if ( monster ) {
				monster->DamagedPlayer( delta );
			}
		}
	} else {
		idPlayer::Damage( inflictor, attacker, dir, damageDefName, damageScale, location );
	}	

	//HUMANHEAD rww - hit feedback
	if (gameLocal.isMultiplayer && attacker && !gameLocal.isClient) { //let's broadcast from the server only, so hit feedback is always reliable
		hhPlayer *killer = NULL;
		if (attacker->IsType(idPlayer::Type)) {
			killer = static_cast<hhPlayer*>(attacker);
		}
		else if (attacker->IsType(hhVehicle::Type)) {
			hhVehicle *veh = static_cast<hhVehicle*>(attacker);
			if (veh->GetPilot() && veh->GetPilot()->IsType(idPlayer::Type)) {
				killer = static_cast<hhPlayer*>(veh->GetPilot());
			}
		}

		if (killer && killer->entityNumber != entityNumber && killer->mpHitFeedbackTime <= gameLocal.time) {
			if (killer == gameLocal.GetLocalPlayer()) {
				//don't provide visual indicator when shooting a teammate
				if (gameLocal.gameType == GAME_TDM && team == killer->team) {
					killer->StartSound( "snd_hitTeamFeedback", SND_CHANNEL_ITEM, 0, false, NULL );
				}
				else {
					if (IsSpiritOrDeathwalking()) {
						killer->StartSound( "snd_hitSpiritFeedback", SND_CHANNEL_ITEM, 0, false, NULL );
					}
					else {
						killer->StartSound( "snd_hitFeedback", SND_CHANNEL_ITEM, 0, false, NULL );
					}

					//hardcoded health ranges for the various flash colors
					float h;
					if (health > 100) {
						h = 0.0f;
					}
					else if (health > 75) {
						h = 0.25f;
					}
					else if (health > 25) {
						h = 0.50f;
					}
					else {
						h = 0.75f;
					}
					SetShaderParm(3, h);
					SetShaderParm(5, -MS2SEC(gameLocal.time)*2);
				}
			}
			else {
				idBitMsg	msg;
				byte		msgBuf[MAX_EVENT_PARAM_SIZE];

				msg.Init(msgBuf, sizeof(msgBuf));
				msg.WriteBits(gameLocal.GetSpawnId(this), 32);
				killer->ServerSendEvent(EVENT_HITNOTIFICATION, &msg, false, -1, killer->entityNumber);
			}

			//see how this feels (and more importantly how destructive it is toward bandwidth)
			//killer->mpHitFeedbackTime = gameLocal.time + USERCMD_MSEC;
		}
	}
	//HUMANHEAD END

	if ( bFrozen ) {
		const idDict *damageDef = gameLocal.FindEntityDefDict( damageDefName );
		if ( damageDef && damageDef->GetInt( "free_cocoon", "0" ) ) {
			Event_Unfreeze();
		}
	}
}

void hhPlayer::DoDeathDrop() {
	// General dropping (for monsters, souls, etc.)
	const idKeyValue *kv = NULL;
	kv = spawnArgs.MatchPrefix( "def_drops", NULL );
	while ( kv ) {

		idStr drops = kv->GetValue();
		idDict args;

		idStr last5 = kv->GetKey().Right(5);
		if ( drops.Length() && idStr::Icmp( last5, "Joint" ) != 0) {

			args.Set( "classname", drops );

			// HUMANHEAD pdm: specify monster so souls can call back to remove body when picked up
			args.Set("monsterSpawnedBy", name.c_str());

			idVec3 origin;
			idMat3 axis;
			idStr jointKey = kv->GetKey() + idStr("Joint");
			idStr jointName = spawnArgs.GetString( jointKey );
			idStr joint2JointKey = kv->GetKey() + idStr("Joint2Joint");
			idStr j2jName = spawnArgs.GetString( joint2JointKey );

			idEntity *newEnt = NULL;
			gameLocal.SpawnEntityDef( args, &newEnt );
			HH_ASSERT(newEnt != NULL);

			if(jointName.Length()) {
				jointHandle_t joint = GetAnimator()->GetJointHandle( jointName );
				if (!GetAnimator()->GetJointTransform( joint, gameLocal.time, origin, axis ) ) {
					gameLocal.Printf( "%s refers to invalid joint '%s' on entity '%s'\n", (const char*)jointKey.c_str(), (const char*)jointName, (const char*)name );
					origin = renderEntity.origin;
					axis = renderEntity.axis;
				}
				axis *= renderEntity.axis;
				origin = renderEntity.origin + origin * renderEntity.axis;
				newEnt->SetAxis(axis);
				newEnt->SetOrigin(origin);
			}
			else {
				newEnt->SetAxis(viewAxis);
				newEnt->SetOrigin(GetOrigin());
			}
		}
		
		kv = spawnArgs.MatchPrefix( "def_drops", kv );
	}
}

//HUMANHEAD rww
/*
==================
hhPlayer::Event_RespawnCleanup
performs any necessary operations on death to prepare for a clean spawn.
only cosmetic things should be placed here, this function will not be called
for sure on death, at least for the client.
==================
*/
void hhPlayer::Event_RespawnCleanup(void) {
	//remove any fx entities which are bound to the player
	idEntity *ent;
	idEntity *next;

	for( ent = teamChain; ent != NULL; ent = next ) {
		next = ent->GetTeamChain();
		if ( ent->GetBindMaster() == this && ent->IsType(hhEntityFx::Type) ) {
			ent->Unbind();
			if( !ent->fl.noRemoveWhenUnbound ) {
				ent->PostEventMS( &EV_Remove, 0 );
				if (gameLocal.isClient) {
					ent->Hide();
				}
			}
			next = teamChain;
		}
	}
}
//HUMANHEAD END

/*
==================
hhPlayer::Killed
==================
*/
void hhPlayer::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
	//you only die once
	if( AI_DEAD ) {
		return;
	}

	CancelEvents(&EV_DamagePlayer); //rww - don't do any more posted damage events once dead

	if (gameLocal.isMultiplayer) { //rww - this was not handled at all, i guess because there are different circumstances for "death" in sp
		wallwalkSoundController.StopSound( SND_CHANNEL_WALLWALK, SND_CHANNEL_WALLWALK2, false );
		spiritwalkSoundController.StopSound( SND_CHANNEL_BODY, SND_CHANNEL_BODY2 );

		LighterOff();

		if (!gameLocal.isClient && weapon.IsValid() && weapon->IsType(hhWeapon::Type) && weapon->CanDrop()) { //when dying in mp, toss my weapon out.
			idVec3 forward, up;

			viewAngles.ToVectors( &forward, NULL, &up );
			//rww - hackishness to keep the type of ammo in the leechgun that it was dropped with
			idEntity *dropped = weapon->DropItem( 50.0f * forward + 50.0f * up, 0, 60000, true );
			if (dropped && weapon->IsType(hhWeaponSoulStripper::Type)) {
				dropped->spawnArgs.Set("def_droppedEnergyType", inventory.energyType);
			}
		}
	}

	if (!gameLocal.isClient) {
		DoDeathDrop();
	}

	if ( gameLocal.isMultiplayer && !gameLocal.IsCooperative() ) {
		bDeathWalk = false;
		bSpiritWalk = false;
		bReallyDead = true;
	}
	else if ( !inventory.requirements.bCanDeathWalk || !gameLocal.DeathwalkMapLoaded() ) {
		bDeathWalk = false;
		bSpiritWalk = false;
		bReallyDead = true;
	}

	//First thing we do is get out of vehicle
	if (InVehicle()) {
		GetVehicleInterface()->GetVehicle()->EjectPilot();
	}

	// HUMANHEAD cjr:  Update DDA
	if ( !AI_DEAD && !gameLocal.isMultiplayer ) {
		gameLocal.GetDDA()->DDA_AddDeath( this, attacker );
	}
	// HUMANHEAD END

	if ( attacker && attacker->spawnArgs.GetBool("death_look_at", "0"))  {
		attacker->spawnArgs.GetString("death_look_at_bone", "", deathLookAtBone); 
		attacker->spawnArgs.GetString("death_camera_bone", "", deathCameraBone );
		deathLookAtEntity = attacker;
	}

	if ( weapon.IsValid() ) {
		//HUMANHEAD bjk 04/26/06 - no sniper scope when dead
		if ( weapon->IsType( hhWeaponRifle::Type ) ) {
			static_cast<hhWeaponRifle*>( weapon.GetEntity() )->ZoomOut();
		}
		weapon->PutAway();
	}

	// HUMANHEAD nla
	if ( hand.IsValid() ) {
		hand->PutAway();
	}
	// HUMANHEAD END

	if ( !bReallyDead ) { // Only go into deathwalk mode if the player is in the transitional death state
		idVec3 origin;
		idMat3 axis;
		idVec3 viewDir;
		idAngles angles;
		idMat3 eyeAxis;
		GetResurrectionPoint( origin, axis, viewDir, angles, eyeAxis, GetPhysics()->GetAbsBounds(), GetOrigin(), GetPhysics()->GetAxis(), GetAxis()[0], viewAngles );
		DeathWalk( origin, axis, viewDir.ToMat3(), angles, eyeAxis );
	} else {
		if (gameLocal.isMultiplayer) { //HUMANHEAD rww
			PostEventMS(&EV_RespawnCleanup, 32);
			if (!gameLocal.isClient) {
				StartRagdoll(); //start to rag on the player so that the proxy copies off proper af status

				GetPhysics()->SetContents( 0 ); //make non-solid

				hhMPDeathProxy *prox = (hhMPDeathProxy *)hhSpiritProxy::CreateProxy( spawnArgs.GetString("def_deathProxy_mp"), this, GetOrigin(), GetPhysics()->GetAxis(), viewAxis, viewAngles, GetEyeAxis() );
				assert(((hhSpiritProxy *)prox)->IsType(hhMPDeathProxy::Type));
				if (prox) {
					idVec3 flingForce;
					float capDmg = (float)damage;
					if (capDmg > 200.0f) {
						capDmg = 200.0f;
					}
						
					flingForce = dir;
					flingForce.Normalize();
					flingForce *= capDmg;

					prox->GetPhysics()->AddForce(0, prox->GetPhysics()->GetOrigin(0), flingForce*256.0f*256.0f);
					prox->SetFling(prox->GetPhysics()->GetOrigin(0), flingForce);
				}

				StopRagdoll(); //stop again, as we don't need to be ragging on the actual player
			}

			Hide(); //hide player

			minRespawnTime = gameLocal.time + RAGDOLL_DEATH_TIME;
			maxRespawnTime = minRespawnTime + 10000;
		} else {
			GetPhysics()->SetContents(0);
			Hide();

			minRespawnTime = gameLocal.time + 2000;
			maxRespawnTime = minRespawnTime + 5000;
		} //HUMANHEAD END

		physicsObj.SetMovementType( PM_DEAD );
		SAFE_REMOVE( weapon );
	}

	AI_DEAD = true;

	//HUMANHEAD rww
	if (gameLocal.isMultiplayer) {
		SetAnimState( ANIMCHANNEL_LEGS, "Legs_Death", 4 );
		SetAnimState( ANIMCHANNEL_TORSO, "Torso_Death", 4 );
		SetWaitState( "" );
	}
	//HUMANHEAD END

	//HUMANHEAD PCF rww 09/15/06 - female mp sounds
	if (IsFemale()) {
		StartSound( "snd_death_female", SND_CHANNEL_VOICE );
	}
	else {
		//HUMANHEAD END
	StartSound( "snd_death", SND_CHANNEL_VOICE );
	}

	if ( gameLocal.isMultiplayer && !gameLocal.isCoop ) {
		idPlayer *killer = NULL;

		if ( attacker->IsType( idPlayer::Type ) ) {
			killer = static_cast<idPlayer*>(attacker);
		}
		else { //rww - otherwise try to credit airAttacker
			if (airAttacker.IsValid() &&
				airAttacker.GetEntity() &&
				airAttackerTime > gameLocal.time) {

				if (airAttacker->IsType(idPlayer::Type)) {
					killer = static_cast<idPlayer*>(airAttacker.GetEntity());
				}
				else if (airAttacker->IsType(hhVehicle::Type)) {
					hhVehicle *veh = static_cast<hhVehicle*>(airAttacker.GetEntity());
					if (veh->GetPilot() && veh->GetPilot()->IsType(idPlayer::Type)) {
						killer = static_cast<idPlayer*>(veh->GetPilot());
					}
				}
			}
		}
		gameLocal.mpGame.PlayerDeath( this, killer, inflictor, false ); //HUMANHEAD rww - pass inflictor
	}

	UpdateVisuals();

	airAttackerTime = 0; //HUMANHEAD rww - reset air attacker time once dead
}

/*
==============
hhPlayer::Kill
==============
*/
void hhPlayer::Kill( bool delayRespawn, bool nodamage ) {
	if (noclip) {	// HUMANHEAD pdm: Because of deathwalk, this shouldn't be allowed
		return;
	}

	if ( health > 0 ) {
		//HUMANHEAD rww
		if (IsSpiritOrDeathwalking()) {
			if (!IsSpiritWalking()) { //don't "kill" when dead.
				return;
			}
			StopSpiritWalk(true);
		}
		//HUMANHEAD END

		godmode = false;
		health = 0;
		//HUMANHEAD rww - if in a vehicle, eject now
		if (InVehicle()) {
			if (vehicleInterfaceLocal.GetVehicle()) {
				vehicleInterfaceLocal.GetVehicle()->EjectPilot();
			}
		}
		//HUMANHEAD END
		Damage( NULL, NULL, vec3_origin, "damage_suicide", 1.0f, INVALID_JOINT );
	}
}

/*
===============
hhPlayer::DetermineOwnerPosition

HUMANHEAD: aob
===============
*/
void hhPlayer::DetermineOwnerPosition( idVec3 &ownerOrigin, idMat3 &ownerAxis ) {
	ownerAxis	= TransformToPlayerSpace( GetUntransformedViewAxis() );
	ownerOrigin = cameraInterpolator.GetCurrentPosition() + idVec3(g_gun_x.GetFloat(), g_gun_y.GetFloat(), g_gun_z.GetFloat()) * GetAxis();
}

/*
===============
hhPlayer::GetViewPos
===============
*/
//HUMANHEAD bjk
void hhPlayer::GetViewPos( idVec3 &origin, idMat3 &axis ) {
	idAngles angles;

	// if dead, fix the angle and don't add any kick
	// HUMANHEAD cjr:  Replaced health <= 0 with IsDead() call for deathwalk override
	if ( IsDead() && !gameLocal.isMultiplayer ) { //rww - don't want this in mp.
	// HUMANHEAD END
		angles.yaw = viewAngles.yaw;
		angles.roll = 40;
		angles.pitch = -15;
		axis = angles.ToMat3();
		origin = GetEyePosition();
	} else {
		assert(kickSpring < 500.0f && kickSpring > 0.0f);
		assert(kickDamping < 500.0f && kickDamping > 0.0f);
		origin = viewBob + TransformToPlayerSpace( idVec3(g_viewNodalX.GetFloat(), g_viewNodalZ.GetFloat(), g_viewNodalZ.GetFloat() + EyeHeight()) );
		axis = TransformToPlayerSpace( (GetUntransformedViewAngles() + viewBobAngles + playerView.AngleOffset(kickSpring, kickDamping)).ToMat3() );		
	}
}

/*
===============
hhPlayer::CalculateRenderView
===============
*/
void hhPlayer::CalculateRenderView( void ) {
	idPlayer::CalculateRenderView();

	// HUMANHEAD cjr
	if ( IsSpiritOrDeathwalking() ) { // If spiritwalking, then allow the player to see special objects
		renderView->viewSpiritEntities = true;
	}
}


/*
===============
hhPlayer::OffsetThirdPersonView
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
===============
*/
void hhPlayer::OffsetThirdPersonView( float angle, float range, float height, bool clip ) {
	idVec3			view;
	trace_t			trace;
	idMat3			lookAxis;
	idVec3			origin;
	idAngles		angles( GetUntransformedViewAngles() );

	if ( angle ) {
		angles.pitch = 0.0f;
	}

	if ( angles.pitch > 45.0f && !InVehicle() ) {
		angles.pitch = 45.0f;		// don't go too far overhead
	}

	//HUMANHEAD: aob
	lookAxis = TransformToPlayerSpace( angles.ToMat3() * idAngles(0.0f, angle, 0.0f).ToMat3() );
	if( InVehicle() ) {
		origin = GetOrigin() + lookAxis[2] * (height + EyeHeight());
	} else {
		origin = GetEyePosition() + GetEyeAxis()[2] * height;
	}
	view = origin + lookAxis[0] * -range;
	// trace a ray from the origin to the viewpoint to make sure the view isn't
	// in a solid block.  Use an 16 by 16 block to prevent the view from near clipping anything
	if( !noclip ) {
		int mask = MASK_SHOT_BOUNDINGBOX;

		if (gameLocal.isMultiplayer) { //rww - don't want this hitting corpses. also, shouldn't we pay attention to "clip"?
			mask = MASK_PLAYERSOLID;
		}

		thirdPersonCameraClipBounds.SetOwner( this );
		idEntity* ignore = (InVehicle()) ? GetVehicleInterface()->GetVehicle() : (idEntity*)this;
		gameLocal.clip.Translation( trace, origin, view, &thirdPersonCameraClipBounds, lookAxis, mask, ignore );
		range *= trace.fraction;
	}

	renderView->vieworg = origin + lookAxis[0] * -range;
	renderView->viewaxis = lookAxis;
	//HUMANHEAD END
	renderView->viewID = 0;
}


/*
==============================
hhPlayer::GetGuiHandInfo
  Retrns the proper gui hand info for a given gui
==============================
*/
const char *hhPlayer::GetGuiHandInfo() {
	const char *attrib;
	idDict	*item = NULL;
	const char *handString;

	// Set the gui to:
	//	"required_attribute"	"Hunter Hand"
	// If item exists in player inventory, player uses guihand specified by item
	if (!IsSpiritWalking() && focusGUIent && focusGUIent->spawnArgs.GetString("required_attribute", NULL, &attrib)) {
		item = FindInventoryItem( attrib );
		if ( item ) {
			if (item->GetString("def_guihand", NULL, &handString)) {
				return handString;
			}
		}
	}

	// If no required attribute/player doesn't have the item, check for a def_guihand string
	if ( focusGUIent && focusGUIent->spawnArgs.GetString( "def_guihand", NULL, &handString ) ) {
		return( handString );
	}

	// Otherwise, use the default player hand
	return spawnArgs.GetString("def_guihand");

}


//=============================================================================
//
// Spirit walk functions
//
//=============================================================================

void hhPlayer::StartSpiritWalk( const bool bThrust, bool force ) {
	hhFxInfo	fxInfo;
	idVec3		origin;
	idMat3		axis;

	//rww - don't do anything on the client
	if (gameLocal.isClient) {
		return;
	}

	if ( bReallyDead ) { // Don't allow spiritwalking if truly dead
		if (force) {
			gameLocal.Error("Attempted to force spirit walk when dead.\n");
		}
		return;
	}

	// Make sure spirit walk isn't disabled
	if ( !bAllowSpirit ) {
		StartSound("snd_spiritWalkDenied", SND_CHANNEL_ANY);
		return;
	}

	spiritWalkToggleTime = gameLocal.time;

	if ( gameLocal.isMultiplayer ) { // CJR:  Don't allow spiritwalking in MP unless the player has spirit power
		if ( GetSpiritPower() <= 0 ) {
			StartSound("snd_spiritWalkDenied", SND_CHANNEL_ANY, 0, true);
			return;
		}
	}

	if ( !force && nextSpiritTime > gameLocal.time ) { // mdl: Make sure they didn't just get knocked back into their body by a wraith
		StartSound("snd_spiritWalkDenied", SND_CHANNEL_ANY);
		return;
	}

	if (!IsSpiritOrDeathwalking()) {
		if ( !gameLocal.IsLOTA() ) { // In LOTA, spirit power never drains
			PostEventMS( &EV_DrainSpiritPower, spiritDrainHeartbeatMS );
		}

		if ( !bThrust ) { // Normal spiritwalking
			EnableEthereal( spawnArgs.GetString( "def_spiritProxy" ), GetOrigin(), GetPhysics()->GetAxis(), viewAxis, viewAngles, GetEyeAxis() );
		} else { // Knocked out by a wraith
			EnableEthereal( spawnArgs.GetString( "def_possessedProxy" ), GetOrigin(), GetPhysics()->GetAxis(), viewAxis, viewAngles, GetEyeAxis() );
		}

		SelectEtherealWeapon();

		spiritwalkSoundController.StartSound( SND_CHANNEL_BODY, SND_CHANNEL_BODY2 );

		// Update HUD
		if (hud) {
			hud->HandleNamedEvent("SwitchToEthereal");
		}

		// Set the player's skin to a glowy effect
		SetSkinByName( spawnArgs.GetString("skin_Spiritwalk") );
		SetShaderParm( SHADERPARM_TIMEOFFSET, 1.0f ); // TEMP: cjr - Required by the forcefield material.  Can remove when a proper spiritwalk texture is made

		// Spawn in a flash
		GetViewPos( origin, axis );
		fxInfo.SetEntity( this );
		fxInfo.RemoveWhenDone( true );
		fxInfo.SetBindBone( "origin" );
		BroadcastFxInfoPrefixed( "fx_spiritWalkFlash", origin, axis, &fxInfo );

		// Thrust the player backwards out of the body
		if ( bThrust ) {
			idVec3 vec = GetPhysics()->GetAxis()[0] * -200.0f + GetPhysics()->GetAxis()[2] * 50.0f;

			physicsObj.SetLinearVelocity( physicsObj.GetLinearVelocity() + vec );
			// set the timer so that the player can't cancel out the movement immediately
			physicsObj.SetKnockBack( 100 );
		}

		// bg - trigger map entity, provides a simple hook for map/scripts
		idEntity *swTrig = gameLocal.FindEntity( "sw_spiritWalkEntered" );
		if( swTrig ) {
			swTrig->PostEventMS( &EV_Activate, 0, this );
		}
	}
}

void hhPlayer::StopSpiritWalk(bool forceAllowance) {
	hhFxInfo	fxInfo;
	idVec3		origin;
	idMat3		axis;

	//rww - don't do anything on the client
	if (gameLocal.isClient) {
		return;
	}

	if ( IsPossessed() ) { // If possessed and the player stops spiritwalking, they die
		PossessKilled();
		return;
	}

	spiritWalkToggleTime = gameLocal.time;

	if ( bReallyDead ) { // Don't allow spiritwalking if truly dead
		return;
	}

	CancelEvents(&EV_SetOverlayMaterial); //HUMANHEAD rww - if being forced back out of spirit mode quickly enough, don't set overlay afterward

	if (IsSpiritOrDeathwalking()) {
		CancelEvents(&EV_DrainSpiritPower);
		if( weapon.IsValid() && weapon->IsType(hhWeaponSpiritBow::Type) ) {
			hhWeaponSpiritBow *bow = static_cast<hhWeaponSpiritBow *>( weapon.GetEntity() );
			if( bow->BowVisionIsEnabled() ) {
				bow->StopBowVision();
			}
		}
		DisableEthereal();
		spiritwalkSoundController.StopSound( SND_CHANNEL_BODY, SND_CHANNEL_BODY2 );
		SetSkin( NULL );

		// bg - trigger map entity, provides a simple hook for map/scripts
		idEntity *swTrig = gameLocal.FindEntity( "sw_spiritWalkExited" );
		if( swTrig ) {
			swTrig->PostEventMS( &EV_Activate, 0, this );
		}

		// Update HUD
		if (hud) {
			hud->HandleNamedEvent("SwitchFromEthereal");
		}
		buttonMask |= BUTTON_ATTACK;	//HUMANHEAD bjk

		// Spawn in a flash
		GetViewPos( origin, axis );
		fxInfo.SetEntity( this );
		fxInfo.RemoveWhenDone( true );
		fxInfo.SetBindBone( "origin" );
		BroadcastFxInfoPrefixed( "fx_spiritWalkFlash", origin, axis, &fxInfo );
	}
}

void hhPlayer::ToggleSpiritWalk( void ) {
	if (spectating) { //rww - do not allow spectators to spirit walk.
		return;
	}

	if ( bPossessed ) { // Cannot toggle away from spiritwalk when possessed
		StartSound("snd_spiritWalkDenied", SND_CHANNEL_ANY);
		return;
	}

	// spiritwalk time check -- force a delay between spiritwalking and not
	if (gameLocal.time < spiritWalkToggleTime + 250) {
		return;
	}

	if( IsSpiritOrDeathwalking() ) {
		StopSpiritWalk();
	} else {
		StartSpiritWalk( false );
	}
}

//HUMANHEAD rww
void hhPlayer::RestorePlayerLocationFromDeathwalk( const idVec3& origin, const idMat3& bboxAxis, const idVec3& viewDir, const idAngles& angles ) {
	idVec3		newOrigin;
	idMat3		newAxis;
	idVec3		newViewDir;
	idAngles	newAngles;

	if( deathwalkLastCrouching ) {
		ForceCrouching();
	}

	SetEyeAxis(deathwalkLastEyeAxis);
	GetResurrectionPoint( newOrigin, newAxis, newViewDir, newAngles, deathwalkLastEyeAxis, GetPhysics()->GetAbsBounds(), deathwalkLastOrigin, deathwalkLastBBoxAxis, viewDir, angles );
	Teleport( newOrigin, newAxis, newViewDir, (newAngles.ToMat3() * deathwalkLastEyeAxis.Transpose()).ToAngles(), NULL );
}
//HUMANHEAD END

//=============================================================================
//
// hhPlayer::EnableEthereal
//
// Sets the player into an ethereal state (used for both spiritwalk and deathwalk)
// This function does the following:
//	- Fade volume down on all class 0 sounds
//	- Sets bSpiritWalk (since this is true for both spirit and death walks)
//	- Spawns a proxy
//  - Sets the new collision
//  - Disables the weapons (the bow is enabled seperately for spiritwalk)
//  - Disables the lighter
//  - Unpossesses the player (if possessed)
//	- Updates bindings
//=============================================================================

void hhPlayer::EnableEthereal( const char *proxyName, const idVec3& origin, const idMat3& bboxAxis, const idMat3& newViewAxis, const idAngles& newViewAngles, const idMat3& newEyeAxis ) {
	//rww - don't do anything on the client - DO NOT PUT ANYTHING ABOVE HERE
	if (gameLocal.isClient)	{
		return;
	}

	// Turn on low-pass effect
	if (gameLocal.localClientNum == entityNumber) { //rww - don't do this for anyone but the local client on listen servers
		gameLocal.SpiritWalkSoundMode( true );
	}

	// Spawn proxy Tommy actor
	spiritProxy = hhSpiritProxy::CreateProxy( proxyName, this, origin, bboxAxis, newViewAxis, newViewAngles, newEyeAxis );

	// Change player's collision type (to allow walking through forcefields, etc)
	GetPhysics()->SetClipMask( MASK_SPIRITPLAYER );
	fl.acceptsWounds = false;
	spawnArgs.Set("produces_splats", "0");

	// HUMANHEAD mdl:  Let our enemies know about the spirit proxy
	for ( int i = 0; i < hhMonsterAI::allSimpleMonsters.Num(); i++ ) {
		if ( hhMonsterAI::allSimpleMonsters[i]->GetEnemy() == this ) {
			hhMonsterAI::allSimpleMonsters[i]->ProcessEvent( &MA_EnemyIsSpirit, this, spiritProxy.GetEntity() );
		}
	}

	// If bound to another object (like on a rail ride), swap bindings with the proxy
	if ( GetBindMaster() != NULL ) {
		if (GetBindMaster()->IsType(hhBindController::Type)) {
			hhBindController *binder = static_cast<hhBindController *>(GetBindMaster());
			bool loose = binder->IsLoose();
			binder->Detach();
			binder->Attach( spiritProxy.GetEntity(), loose );
		} else {
			gameLocal.Warning("Handle this: spiritwalking while bound to non-rail");
			SwapBindInfo( spiritProxy.GetEntity() );	// untested
		}
	}

	SnapDownCurrentWeapon();

	LighterOff();

	// Set the player into spiritwalk mode
	bSpiritWalk = true;
}

//=============================================================================
//
// hhPlayer::DisableEthereal
//
// Returns the player from an ethereal state (used for both spiritwalk and deathwalk)
// This function does the following:
//	- Clears bSpiritWalk (since this is true for both spirit and death walks)
//	- Removes the proxy
//  - Sets the new collision
//  - Re-enables the weapons
//	- Updates bindings
//	- Fade volume back up on all class 0 sounds
//=============================================================================

void hhPlayer::DisableEthereal( void ) {
	hhFxInfo	fxInfo;
	idVec3		boneOffset;
	idMat3		boneAxis;

	//rww - don't do anything on the client - DO NOT PUT ANYTHING ABOVE HERE
	if (gameLocal.isClient) {
		return;
	}

	bSpiritWalk = false;

	// Spawn in an effect when the spirit is snapped back
	GetJointWorldTransform( "waist", boneOffset, boneAxis );	
	fxInfo.RemoveWhenDone( true );
	fxInfo.SetNormal( boneAxis[1] );
	BroadcastFxInfo( spawnArgs.GetString( "fx_spiritReturn" ), boneOffset, GetAxis(), &fxInfo );

	if( spiritProxy.IsValid() ) {
		// Handle case of returning to a body on a rail ride
		idEntity *spiritMaster = spiritProxy->GetBindMaster();
		if (spiritMaster != NULL) {
			if (spiritMaster->IsType(hhBindController::Type)) {
				hhBindController *binder = static_cast<hhBindController *>(spiritMaster);
				bool loose = binder->IsLoose();
				binder->Detach();
				spiritProxy->DeactivateProxy();
				binder->Attach(this, loose);
			} else if (spiritMaster->IsType(hhMonsterAI::Type)) {
				if (reinterpret_cast<hhMonsterAI *> (spiritMaster)->GetEnemy() != static_cast<idActor *> (spiritProxy.GetEntity())) {
					gameLocal.Warning("Monster has spirit proxy bound to it but spirit proxy is not it's enemy!\n");
				}
				spiritProxy->DeactivateProxy();
			} else {
				gameLocal.Warning("Handle this: spiritwalking while bound to non-rail");
				idEntity *temp = spiritProxy.GetEntity();	// this removed by DeactivateProxy
				spiritProxy->DeactivateProxy();
				SwapBindInfo(temp);	// untested
			}
		}
		else {	// Normal case
			spiritProxy->DeactivateProxy();
		}
	}

	PutawayEtherealWeapon();

	GetPhysics()->SetClipMask( MASK_PLAYERSOLID );
	fl.acceptsWounds = true;
	spawnArgs.Set("produces_splats", "1");

	// Turn off low-pass effect
	if (gameLocal.localClientNum == entityNumber) { //rww - don't do this for anyone but the local client on listen servers
		gameLocal.SpiritWalkSoundMode( false );
	}

	// HUMANHEAD mdl:  Let our enemies know the spirit proxy is going away
	for ( int i = 0; i < hhMonsterAI::allSimpleMonsters.Num(); i++ ) {
		if ( hhMonsterAI::allSimpleMonsters[i]->GetEnemy() == spiritProxy.GetEntity() ) {
			hhMonsterAI::allSimpleMonsters[i]->ProcessEvent( &MA_EnemyIsPhysical, this, spiritProxy.GetEntity() );
		} else if ( hhMonsterAI::allSimpleMonsters[i]->GetEnemy() == this ) { // Targetting spirit that is going away
			hhMonsterAI::allSimpleMonsters[i]->ProcessEvent( &MA_EnemyIsPhysical, this, NULL );
		}
	}

	//HUMANHEAD rww - clear the focus now that we've changed positions by switching out of spirit mode
	focusTime = 0;
	UpdateFocus();
	//HUMANHEAD END

	spiritProxy = NULL;
}

//=============================================================================
//
// hhPlayer::GetResurrectionPoint
//
// Get the position/orientation for resurrection after deathwalk
//=============================================================================
void hhPlayer::GetResurrectionPoint( idVec3& origin, idMat3& axis, idVec3& viewDir, idAngles& angles, idMat3& eyeAxis, const idBounds& absBounds, const idVec3& defaultOrigin, const idMat3& defaultAxis, const idVec3& defaultViewDir, const idAngles& defaultAngles ) {
	idClipModel *clipModelList[ MAX_GENTITIES ];
	idClipModel* clipModel = NULL;
	idEntity*	entity = NULL;
	hhSafeResurrectionVolume* volume = NULL;

	int num = gameLocal.clip.ClipModelsTouchingBounds( absBounds, CONTENTS_DEATHVOLUME, clipModelList, MAX_GENTITIES );
	for( int ix = 0; ix < num; ++ix ) {
		clipModel = clipModelList[ix];

		if( !clipModel ) {
			continue;
		}

		entity = clipModel->GetEntity();
		if( !entity || !entity->IsType(hhSafeResurrectionVolume::Type) ) {
			continue;
		}

		volume = static_cast<hhSafeResurrectionVolume*>( entity );
		volume->PickRandomPoint( origin, axis );
		viewDir = axis[0];
		angles = axis.ToAngles();
		eyeAxis = mat3_identity;
		return;
	}

	eyeAxis = GetEyeAxis();
	origin = defaultOrigin;
	axis = defaultAxis;
	viewDir = defaultViewDir;
	angles = defaultAngles;

//	gameLocal.Printf("Deathwalk @:\n");
//	gameLocal.Printf("  origin:		%s\n", origin.ToString(0));
//	gameLocal.Printf("  axis:		%s\n", axis.ToString(2));
//	gameLocal.Printf("  viewDir:	%s\n", viewDir.ToString(2));
//	gameLocal.Printf("  angles:		%s\n", angles.ToString(0));
}


//=============================================================================
//
//	hhPlayer::SquishedByDoor
//
//=============================================================================
void hhPlayer::SquishedByDoor(idEntity *door) {
	if ( door == this ) { // Don't allow the squished code to send a player back it the squisher is the player itself
		return;
	}

	// If there is a spirit player in the door, make him go back to physical so he doesn't become stuck
	if (IsSpiritWalking()) {
		StopSpiritWalk();
	}
}

//=============================================================================
//
// hhPlayer::UpdatePossession
//
// Updates the possession effects (if the player is possessed)
//
// HUMANHEAD cjr
//=============================================================================

void hhPlayer::UpdatePossession( void ) {

	if ( !IsPossessed() ) { // Player is not possessed
		return;
	}

/* todo:
	possessionTimer -= MS2SEC( USERCMD_MSEC );
		
	// Update a shaderparm for the view screen to update based upon possessionTimer
	possessionMax = spawnArgs.GetFloat( "possessionTime", "8" );
	possessionScale = possessionTimer / possessionMax;
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, possessionScale ) );

	// Mess with the player's FOV while they are being possessed
	possessionFOV = g_fov.GetFloat() + (1.0f - possessionScale) * 60 + 1.5f * sin( MS2SEC(gameLocal.time) * 3 );

	if ( possessionTimer <= 0 ) { // The player is now fully possessed, kill them
		// TODO:  Extra code to show the possessed player running around and such?
		Unpossess();
		Damage( NULL, NULL, vec3_origin, "damage_crush", 1.0f, INVALID_JOINT );
	}
*/
}

//=============================================================================
//
// hhPlayer::RechargeHealth
//
// Recharges the player's health to 25%
//
// This is done to avoid gameplay issues where the player has only a few points
// of health.  The game will still be tense if the player is at 25%, but
// will play more fairly.
//
// HUMANHEAD cjr
//=============================================================================

void hhPlayer::Event_RechargeHealth( void ) {

	if ( health > 0 && health < spawnArgs.GetInt( "healthRecharge", "25" ) && !IsSpiritOrDeathwalking() ) { // Only recharge if the player is alive and in the critical zone		
		if ( gameLocal.time - lastDamagedTime >= spawnArgs.GetInt( "healthRechargeDelay", "1500" ) ) { // Delay before recharging
			health++;
		}
	}

	PostEventSec( &EV_RechargeHealth, spawnArgs.GetFloat( "healthRechargeRate", "0.5" ) );
}

//=============================================================================
//
// hhPlayer::RechargeRifleAmmo
//
// Recharges rifle ammo if the player is very low.  This is done to guarantee
// that the player has at least some ammo to solve puzzles that require shooting
// something such as a gravity switch.
//
// HUMANHEAD cjr
//=============================================================================

void hhPlayer::Event_RechargeRifleAmmo( void ) {

	int ammoIndex = inventory.AmmoIndexForAmmoClass( "ammo_rifle" );
	int ammoCount = inventory.ammo[ ammoIndex ];

	int maxAmmo = spawnArgs.GetInt( "rifleAmmoRechargeMax", "20" );
	if ( ammoCount < maxAmmo && !AI_ATTACK_HELD ) { // CJR PCF 04/26/06
		inventory.ammo[ ammoIndex ] += 2;
		if ( inventory.ammo[ ammoIndex ] > maxAmmo ) {
			inventory.ammo[ ammoIndex ] = maxAmmo;
		}
	}

	PostEventSec( &EV_RechargeRifleAmmo, spawnArgs.GetFloat( "rifleAmmoRechargeRate", "2" ) );
}

//=============================================================================
//
// hhPlayer::Event_DrainSpiritPower
//
// HUMANHEAD pdm: 10 Hz timer used to drain spirit power at differing rates
//=============================================================================
void hhPlayer::Event_DrainSpiritPower() {

	// JRM: God mode, don't drain! 
	if(godmode) {
		return;
	}

	ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName( "ammo_spiritpower" );

	if ( gameLocal.isMultiplayer ) { // CJR:  Drain spirit power in MP
		if ( !UseAmmo( ammo_spiritpower, 1 ) ) {
			StopSpiritWalk();
			return;
		}
	}

	// spirit bow alt mode drain
	if( weapon.IsValid() && weapon->IsType(hhWeaponSpiritBow::Type) ) {
		hhWeaponSpiritBow *bow = static_cast<hhWeaponSpiritBow *>( weapon.GetEntity() );
		if( bow->BowVisionIsEnabled() ) {
			if( !UseAmmo(ammo_spiritpower, 1) ) { // Bow vision drains spirit power
				return;
			}
		}
	}

	PostEventMS( &EV_DrainSpiritPower, spiritDrainHeartbeatMS );
}

//=============================================================================
//
// hhPlayer::DeathWalk
//
//=============================================================================

void hhPlayer::DeathWalk( const idVec3& resurrectOrigin, const idMat3& resurrectBBoxAxis, const idMat3& resurrectViewAxis, const idAngles& resurrectViewAngles, const idMat3& resurrectEyeAxis ) {
	if ( IsSpiritWalking() ) { // Ensure that two proxies cannot be active at the same time
		StopSpiritWalk();
	}

	bDeathWalk = true;
	deathWalkTime = gameLocal.time; // Get the time of death

	health = 0; // Force health to zero

	deathWalkPower = spawnArgs.GetInt( "deathWalkPowerStart" ); // Power in deathwalk.  When full, the player will return
	fl.takedamage = false; // can no longer be damaged in deathwalk mode

	if (hud) {
		hud->HandleNamedEvent("SwitchToEthereal");
	}

	// Disable clip until we get to deathwalk
	bInDeathwalkTransition = true;

	//rww - for deathwalk, let's store these values on the player instead of relying on the death proxy
	deathwalkLastOrigin = resurrectOrigin;
	deathwalkLastBBoxAxis = resurrectBBoxAxis;
	deathwalkLastViewAxis = resurrectViewAxis;
	deathwalkLastViewAngles = resurrectViewAngles;
	deathwalkLastEyeAxis = resurrectEyeAxis;
	deathwalkLastCrouching = IsCrouching();

	EnableEthereal( spawnArgs.GetString("def_deathProxy"), resurrectOrigin, resurrectBBoxAxis, resurrectViewAxis, resurrectViewAngles, resurrectEyeAxis );
	// Set the overlay material for DeathWalk
	playerView.SetViewOverlayColor( colorWhite ); // Guarantee that the color is reset
	PostEventMS( &EV_SetOverlayMaterial, 1, spawnArgs.GetString("mtr_deathWalk"), false );

	//Don't allow weapon use for a bit
	if ( weapon.GetEntity() ) {
		weapon.GetEntity()->PutAway();
	}

	// Alert the scripts that death has occured so they can manage music
	idEntity *dwJustDied = gameLocal.FindEntity("dw_justdied");
	if (dwJustDied) {
		dwJustDied->PostEventMS(&EV_Activate, 0, this);
	}

	deathwalkSoundController.StartSound( SND_CHANNEL_BODY, SND_CHANNEL_BODY2 );

	// Flash the screen before entering death world
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, 0.0f ) );
	deathWalkFlash = 0.0f;
	possessionFOV = 90.0f;

	CancelEvents( &EV_RechargeHealth );
	CancelEvents( &EV_RechargeRifleAmmo );

	// If this is our first time, tell the script
	if (!gameLocal.IsCompetitive() && !inventory.bHasDeathwalked) {
		const function_t *firstFunc = gameLocal.program.FindFunction( "map_deathwalk::FirstDeathwalk" );
		if ( firstFunc ) {
			idThread *thread = new idThread();
			thread->CallFunction( firstFunc, false );
			thread->DelayedStart( 0 );
		}
	}

	//rww - if there is a deathwalk portal, let's create a target for it and activate it
	if (!gameLocal.FindEntity("dw_deathLocation")) { //check to see if we've made ourselves a target yet
		idEntity *dwPortal = gameLocal.FindEntity( "dw_deathPortal" );
		if (dwPortal) {
			trace_t tr;
			idVec3 camPos, camDir;
			idAngles camAngles;
			idDict args;

			//FIXME more complex logic that allows angles to change based on collision circumstances
			//do wider trace that takes the actual view frustum of camera into account
			//check for collisions with the actual view "plane"
			camPos = resurrectOrigin;
			camPos += resurrectBBoxAxis[2] * 64.0f;
			gameLocal.clip.TracePoint(tr, resurrectOrigin, camPos, CONTENTS_SOLID, this);
			camDir = resurrectOrigin-camPos;
			camAngles = camDir.ToAngles();

			args.Clear();
			args.SetVector("origin", tr.endpos);
			args.SetAngles("angles", camAngles);
			args.SetMatrix("rotation", camAngles.ToMat3());
			args.Set("name", "dw_deathLocation");
			gameLocal.SpawnObject("info_null", &args);

			dwPortal->ProcessEvent(&EV_UpdateCameraTarget); //update for the newly placed cameraTarget
			dwPortal->PostEventMS(&EV_Activate, 0, this);
			if (dwPortal->cameraTarget) { //if camera target was legitimate, force an update to the remoteRenderView now
				dwPortal->GetRenderEntity()->remoteRenderView = dwPortal->cameraTarget->GetRenderView();
			}
		}
	}

	Hide(); // Don't show the player when they are in the limbo state between alive and dead
	PostEventSec( &EV_PrepareForDeathWorld, spawnArgs.GetFloat( "prepareForDeathWorldDelay", "1.5" ) );
}

//=============================================================================
//
// hhPlayer::Event_PrepareForDeathWorld
//
// Flashes the screen / fades the FOV
//=============================================================================

void hhPlayer::Event_PrepareForDeathWorld() {	
	deathWalkFlash += spawnArgs.GetFloat( "deathWalkFlashChange", "0.05" );
	if ( deathWalkFlash >= 1.0f ) {
		deathWalkFlash = 1.0f;
		PostEventSec( &EV_EnterDeathWorld, 0.0f ); // Actually send player into the deathworld
	} else {
		PostEventSec( &EV_PrepareForDeathWorld, 0.02f );
	}

	possessionFOV += spawnArgs.GetFloat( "deathWalkFOVChange", "3.0" );
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, deathWalkFlash ) );
}

//=============================================================================
//
// hhPlayer::Event_EnterDeathWorld
//
// - Teleports the player to the death world
// - Spawns the death wraiths
// - Gives the player a weapon
//=============================================================================

void hhPlayer::Event_EnterDeathWorld() {
	// Reset player view information
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, 0.0f ) ); // Turn off the flash
	possessionFOV = 0.0f;
	bDeathWalkStage2 = false;

	// Spawn in DeathWraiths after a short period of time
	if ( !inventory.bHasDeathwalked ) { // Delay the wraiths the first time the player deathwalks
		int firstDelay = spawnArgs.GetInt( "deathWalk_firstTimeDelay", "15000" );
		PostEventMS( &EV_SpawnDeathWraith, firstDelay ); // CJR:  delay the deathwraiths for several seconds while the Grandfather DW speech is going on
		PostEventMS( &EV_AdjustSpiritPowerDeathWalk, firstDelay + 2000 );
		inventory.bHasDeathwalked = true;
	} else {
		PostEventMS( &EV_SpawnDeathWraith, 0 ); // CJR:  Non-first time, spawn the wraiths instantly
		PostEventMS( &EV_AdjustSpiritPowerDeathWalk, 2000 );
	}

	// Give the player the spirit bow
	SelectEtherealWeapon();

	// get the entity which tells us where we want to place our dw proxy
	idEntity *dwProxyPosEnt = gameLocal.FindEntity( "dw_floatingBodyMarker" );
	if (dwProxyPosEnt) {
		//if we found that, then this is the new deathwalk, so create the deathwalk proxy.
		hhDeathWalkProxy *dwProxy = (hhDeathWalkProxy *)gameLocal.SpawnObject( spawnArgs.GetString("def_deathWalkProxy"), NULL );
		if (!dwProxy) {
			gameLocal.Error("hhPlayer::Event_EnterDeathWorld: Could not create hhDeathWalkProxy");
			return;
		}
		idAngles dwProxyAngles;
		dwProxyPosEnt->spawnArgs.GetAngles("angles", "0 0 0", dwProxyAngles);
		dwProxy->ActivateProxy(this, dwProxyPosEnt->GetOrigin(), dwProxyAngles.ToMat3(), dwProxyAngles.ToMat3(), dwProxyAngles, GetEyeAxis());
	}

	idEntity* deathWalkPlayerStartManager = gameLocal.FindEntity( "dw_deathWalkPlayerStartManager" );
	if( !deathWalkPlayerStartManager ) {
		return;
	}

	idEntity* deathWalkStart = deathWalkPlayerStartManager->PickRandomTarget();
	if( deathWalkStart ) {
		deathWalkStart->ProcessEvent( &EV_Activate, this );
	}

	// Trigger the 'DeathWalkEntered' entity
	// This allows the scripters to do something upon entering deathwalk
	idEntity *dwe = gameLocal.FindEntity("dw_DeathWalkEntered");
	if (dwe) {
		dwe->PostEventMS(&EV_Activate, 0, this);
	}

	// Allow collisions again now that we're in the death world
	bInDeathwalkTransition = false;
	Show(); // The player is visible in deathmode

	// Reset the player's health and spirit power
	ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName( "ammo_spiritpower" );
	inventory.ammo[ ammo_spiritpower ] = 0;
	SetHealth( hhMath::hhMax( health, spawnArgs.GetInt("minResurrectHealth", "50") ) );
}

//=============================================================================
//
// hhPlayer::Event_AdjustSpiritPowerDeathWalk
//
//=============================================================================
void hhPlayer::Event_AdjustSpiritPowerDeathWalk() {
	if( !IsDeathWalking() ) {
		return;
	}

	// Increase deathwalk power
	int power = GetDeathWalkPower();
	power += spawnArgs.GetInt( "deathWraithPowerAmount" );
	SetDeathWalkPower( power );

	// Check if deathWalkPower has exceeded the maximum
	if ( deathWalkPower >= spawnArgs.GetInt( "deathWalkPowerMax", "1000") ) {
		DeathWalkSuccess();
		return;
	}

	CancelEvents( &EV_AdjustSpiritPowerDeathWalk );
	PostEventSec( &EV_AdjustSpiritPowerDeathWalk, spawnArgs.GetFloat("deathWalkDeathPowerIncreaseRate") );
}

//=============================================================================
//
// hhPlayer::DeathWalkSuccess
//
// Called when deathwalk timer runs out or we run out of spirit power
//=============================================================================
void hhPlayer::DeathWalkSuccess() {
	CancelEvents( &EV_AdjustSpiritPowerDeathWalk );
	bDeathWalkStage2 = true;

	idEntity *dw_deathWalkResult = gameLocal.FindEntity("dw_deathWalkSuccess");
	if (dw_deathWalkResult) { //if we have a result, activate it.
		dw_deathWalkResult->ProcessEvent(&EV_Activate, this);
	}
}

//=============================================================================
//
// hhPlayer::ReallyKilled
//
// Called when the player should be truly killed
// Funnels through Killed(), but disabled the deathwalk functionality
//=============================================================================

void hhPlayer::ReallyKilled( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
	if ( !IsSpiritOrDeathwalking() ) {
		return;
	}

	bDeathWalk = false;
	bSpiritWalk = false;

	bReallyDead = true;

	// Turn off low-pass effect
	if (!gameLocal.isClient) { //rww
		if (gameLocal.localClientNum == entityNumber) { //rww - don't do this for anyone but the local client on listen servers
			gameLocal.SpiritWalkSoundMode( false );
			gameLocal.DialogSoundMode( false );
		}
	}

	if (hud) {
		hud->HandleNamedEvent("SwitchFromEthereal");
	}

	Killed( inflictor, attacker, damage, dir, location );
}

//=============================================================================
//
// hhPlayer::Event_SpawnDeathWraith
//
// Spawns in a special type of wraith that is only visible in deathwalk
//=============================================================================

void hhPlayer::Event_SpawnDeathWraith() {
	idDict		args;
	idEntity	*ent;
	int			maxDeathWalkWraiths = spawnArgs.GetInt( "deathWalkMaxWraiths" );

	if ( !IsDeathWalking() ) { // Don't spawn in a wraith if the player has resurrected
		return;
	}

	float angle = hhMath::PI * gameLocal.random.RandomFloat();
	idVec3 startPoint = idVec3( hhMath::Sin(angle) * 600.0f, hhMath::Cos(angle) * 600.0f, 0.0f ) - GetAxis()[2] * 100.0f;

	args.Clear();
	args.SetVector( "origin", GetEyePosition() + startPoint );
	args.SetMatrix( "rotation", idAngles( 0.0f, (-viewAxis[0]).ToYaw(), 0.0f ).ToMat3() );
	ent = gameLocal.SpawnObject( spawnArgs.GetString("def_deathWraith"), &args );
	if ( ent ) {
		hhDeathWraith *wraith = static_cast< hhDeathWraith * > ( ent );
		wraith->SetEnemy( this );
	}

	// Check the number of deathwraiths in the world
	int count = 0;
	for( ent = gameLocal.activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
		if ( ent && ent->IsType( hhDeathWraith::Type ) ) {
			count++;			
		}
	}

	if ( count < maxDeathWalkWraiths ) {
		PostEventMS( &EV_SpawnDeathWraith, 0 );
	}
}

//=============================================================================
//
// hhPlayer::GetDeathwalkEnergyDestination
//
//=============================================================================
idEntity *hhPlayer::GetDeathwalkEnergyDestination() {
	return gameLocal.FindEntityOfType(hhDeathWalkProxy::Type, NULL);
}

//=============================================================================
//
// hhPlayer::DeathWalkDamagedByWraith
//
//=============================================================================
void hhPlayer::DeathWalkDamagedByWraith(idEntity *attacker, const char *damageType) {
	Damage( attacker, attacker, vec3_origin, damageType, spawnArgs.GetFloat( "deathWalkWraithDamage", "10" ), INVALID_JOINT );

	CancelEvents( &EV_SpawnDeathWraith );
	PostEventMS( &EV_SpawnDeathWraith, 0 );
}

//=============================================================================
//
// hhPlayer::KilledDeathWraith
//
//=============================================================================

void hhPlayer::KilledDeathWraith( void ) {
	CancelEvents( &EV_SpawnDeathWraith );
	PostEventMS( &EV_SpawnDeathWraith, 0 );
}

//=============================================================================
//
// hhPlayer::DeathWraithEnergyArived
//
//=============================================================================

void hhPlayer::DeathWraithEnergyArived(bool energyHealth) {
	if (energyHealth) {
		const char *healthAmount = spawnArgs.GetString("deathWraithHealthAmount");
		Give( "health", healthAmount );
	}
	else {
		Give( "ammo_spiritpower", spawnArgs.GetString( "deathWraithSpiritAmount" ) );
	}

	// Bump the deathwalk power up a bit so the player lowers faster
	int power = GetDeathWalkPower();
	power += spawnArgs.GetInt( "deathWalkPowerEnergyBoost", "100" );
	SetDeathWalkPower( power );
}

//=============================================================================
//
// hhPlayer::Resurrect
//
//=============================================================================

void hhPlayer::Resurrect( void ) {

	bDeathWalk = false;

	possessionFOV = 0.0f;

	PostEventSec( &EV_AllowDamage, 3 ); // Re-enable damage in 3 seconds
	fl.noknockback = false;	// Restore knockback ability

	// Cancel the impending translation to deathworld (only happens if the player resurrect cheats early)
	CancelEvents( &EV_PrepareForDeathWorld );
	CancelEvents( &EV_EnterDeathWorld );
	CancelEvents( &EV_SpawnDeathWraith );

	DisableEthereal();

	// Reset the view overlay
	playerView.SetViewOverlayTime( 0, true );
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, 0.0f ) );

	//rww - deathwalk position is restored from the player now.
	RestorePlayerLocationFromDeathwalk(deathwalkLastOrigin, deathwalkLastBBoxAxis, deathwalkLastViewAxis[0], deathwalkLastViewAngles);

	deathwalkSoundController.StopSound( SND_CHANNEL_BODY, SND_CHANNEL_BODY2 );

	ProcessEvent( &EV_RechargeHealth );
	ProcessEvent( &EV_RechargeRifleAmmo );

	if (hud) {
		hud->HandleNamedEvent("SwitchFromEthereal");
	}

	// TODO:  Build in an autoimmune time?
	lastResurrectTime = gameLocal.GetTime();

	// Radius blast (doesn't damage enemies / objects, only shoves them back)
	gameLocal.RadiusDamage( GetPhysics()->GetOrigin(), this, this, this, this, spawnArgs.GetString("def_resurrect_damage") );	

	Show(); // Ensure that the player is visible when they resurrect

	// trigger the 'DeathWalkExited' entity
	idEntity *dwe = gameLocal.FindEntity("dw_DeathWalkExited");
	if (dwe) {
		dwe->PostEventMS(&EV_Activate, 0, this);
	}

	// bg: Visual effect for returning from DeathWalk uses landing camera movement.
	landChange = -10;
	landTime = gameLocal.time;

	//rww - deactivate dw portal and remove cam target
	idEntity *dwPortal = gameLocal.FindEntity( "dw_deathPortal" );
	if (dwPortal && dwPortal->IsActive()) {
		dwPortal->cameraTarget = NULL; //reset the camera target
		dwPortal->PostEventMS(&EV_Activate, 0, dwPortal);
	}
	idEntity *dwCamTarget = gameLocal.FindEntity( "dw_deathLocation" );
	if (dwCamTarget) {
		dwCamTarget->PostEventMS(&EV_Remove, 50); //make sure this is removed after the portal has stopped.
	}
}

/*
============
hhPlayer::IsWallWalking
============
*/
bool hhPlayer::IsWallWalking( void ) const {
	return( physicsObj.IsWallWalking() );
}

/*
============
hhPlayer::WasWallWalking
============
*/
bool hhPlayer::WasWallWalking( void ) const {
	return( physicsObj.WasWallWalking() );
}

/*
============
hhPlayer::MangleControls
============
*/
void hhPlayer::MangleControls( usercmd_t *cmd ) {
	// When frozen in a cinematic, we want to restrict any movement and disallow many features
	if (guiWantsControls.IsValid()) {
		if (cmd->buttons & BUTTON_ATTACK_ALT) {
			guiWantsControls->LockedGuiReleased(this);
			guiWantsControls = NULL;	// release
		}
		else {
			guiWantsControls->PlayerControls(cmd);
		}
		cmd->forwardmove = 0;
		cmd->rightmove = 0;
		cmd->upmove = 0;
		cmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ZOOM|BUTTON_ATTACK_ALT);
		cmd->impulse = 0;
	}
	else if (InCinematic()) {
		cmd->forwardmove = 0;
		cmd->rightmove = 0;
		cmd->upmove = 0;
		cmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ZOOM|BUTTON_ATTACK_ALT);
		cmd->impulse = 0;
	}
}

/*
============
hhPlayer::GetPilotInput

Called from PilotVehicleInterface
============
*/
void hhPlayer::GetPilotInput( usercmd_t& pilotCmds, idAngles& pilotViewAngles ) {
	pilotCmds = gameLocal.usercmds[ entityNumber ];
	pilotViewAngles = DetermineViewAngles( pilotCmds, cmdAngles );
}

/*
==============
hhPlayer::Think
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
==============
*/
void hhPlayer::Think( void ) {
	renderEntity_t *headRenderEnt;

	UpdatePossession();

	UpdatePlayerIcons();

	// latch button actions
	oldButtons = usercmd.buttons;

	// grab out usercmd
	usercmd_t oldCmd = usercmd;
	usercmd = gameLocal.usercmds[ entityNumber ];
	buttonMask &= usercmd.buttons;
	usercmd.buttons &= ~buttonMask;

	if ( gameLocal.inCinematic && gameLocal.skipCinematic ) {
		return;
	}

	//HUMANHEAD rww - keep air attacker timer refreshed
	if (!AI_ONGROUND && airAttackerTime > gameLocal.time) {
		airAttackerTime = gameLocal.time + 300;
	}

	// HUMANHEAD pdm: Depending on our mode, might want to modify the input
	MangleControls( &usercmd );
	// HUMANHEAD END

	// clear the ik before we do anything else so the skeleton doesn't get updated twice
	walkIK.ClearJointMods();

	// if this is the very first frame of the map, set the delta view angles
	// based on the usercmd angles
	if ( !spawnAnglesSet && ( gameLocal.GameState() != GAMESTATE_STARTUP ) ) {
		spawnAnglesSet = true;
		SetViewAngles( spawnAngles );
		oldFlags = usercmd.flags;
	}

	if ( gameLocal.inCinematic || influenceActive ) {
		usercmd.forwardmove = 0;
		usercmd.rightmove = 0;
		usercmd.upmove = 0;
	}

	// log movement changes for weapon bobbing effects
	if ( usercmd.forwardmove != oldCmd.forwardmove ) {
		loggedAccel_t	*acc = &loggedAccel[currentLoggedAccel&(NUM_LOGGED_ACCELS-1)];
		currentLoggedAccel++;
		acc->time = gameLocal.time;
		acc->dir[0] = usercmd.forwardmove - oldCmd.forwardmove;
		acc->dir[1] = acc->dir[2] = 0;
	}

	if ( usercmd.rightmove != oldCmd.rightmove ) {
		loggedAccel_t	*acc = &loggedAccel[currentLoggedAccel&(NUM_LOGGED_ACCELS-1)];
		currentLoggedAccel++;
		acc->time = gameLocal.time;
		acc->dir[1] = usercmd.rightmove - oldCmd.rightmove;
		acc->dir[0] = acc->dir[2] = 0;
	}

	// freelook centering
	if ( ( usercmd.buttons ^ oldCmd.buttons ) & BUTTON_MLOOK ) {
		centerView.Init( gameLocal.time, 200, viewAngles.pitch, 0 );
	}

	// zooming
	if ( ( usercmd.buttons ^ oldCmd.buttons ) & BUTTON_ZOOM ) {
		if ( ( usercmd.buttons & BUTTON_ZOOM ) && weapon.GetEntity() ) {
			zoomFov.Init( gameLocal.time, 200.0f, CalcFov( false ), weapon.GetEntity()->GetZoomFov() );
		} else {
			zoomFov.Init( gameLocal.time, 200.0f, zoomFov.GetCurrentValue( gameLocal.time ), DefaultFov() );
		}
	} 

	if ( g_fov.IsModified() ) {
		idEntity *weaponEnt = weapon.GetEntity();
		if ( ! ( weaponEnt &&
				 weaponEnt->IsType( hhWeaponZoomable::Type ) &&
				 reinterpret_cast<hhWeaponZoomable *> (weaponEnt)->IsZoomed() ) )
		{
			GetZoomFov().Init( gameLocal.GetTime(), 0.0f, CalcFov(true), g_fov.GetInteger() );
			g_fov.ClearModified();
		}
	}

	// if we have an active gui, we will unrotate the view angles as
	// we turn the mouse movements into gui events
	idUserInterface *gui = ActiveGui();
	if ( gui && gui != focusUI ) {
		RouteGuiMouse( gui );
	}

	// set the push velocity on the weapon before running the physics
	if ( weapon.GetEntity() ) {
		weapon.GetEntity()->SetPushVelocity( physicsObj.GetPushedLinearVelocity() );
	}

	EvaluateControls();

	if ( !af.IsActive() ) {
		AdjustBodyAngles();
		CopyJointsFromBodyToHead();
	}

	//HUMANHEAD: aob - added vehicle check.  Vehicle moves us
	if( !InVehicle() ) {
		Move();
	}
	//HUMANHEAD END

	if ( !g_stopTime.GetBool() ) {
		//HUMANHEAD: aob - changed heath check to IsDead check.  Player needs to touch triggers when deathwalking.
		if ( !noclip && !spectating && !IsDead() && !IsHidden() ) {
			TouchTriggers();
		}

		UpdateLighter();

		// update GUIs, Items, and character interactions
		UpdateFocus();
	
		UpdateLocation();

		// update player script
		UpdateScript();

		// service animations
		if ( !spectating && !af.IsActive() && !gameLocal.inCinematic ) {
    		UpdateConditions();
			UpdateAnimState();
			CheckBlink();
		}
	
		// clear out our pain flag so we can tell if we recieve any damage between now and the next time we think
		AI_PAIN = false;
	}

	// calculate the exact bobbed view position, which is used to
	// position the view weapon, among other things
	CalculateFirstPersonView();

	// this may use firstPersonView, or a thirdPeroson / camera view
	CalculateRenderView();

	if ( spectating ) {
		if (!gameLocal.isClient) {
			UpdateSpectating();
		}
	//HUMANHEAD: aob - changed heath check to IsDead check.  Player needs to update weapon when deathwalking
	} else if ( !IsDead() && !bFrozen ) {	//HUMANHEAD bjk PCF (4-27-06) - no setting unnecessary weapon state
		if ( !gameLocal.isClient || weapon.GetEntity()) {
			UpdateWeapon();
		}
	}

	if (InVehicle()) {
		UpdateHud( GetVehicleInterfaceLocal()->GetHUD() );
	}
	else {
		UpdateHud( hud );
	}

	UpdateDeathSkin( false );

	if ( gameLocal.isMultiplayer ) {
		DrawPlayerIcons();
	}

	if ( head.GetEntity() ) {
		headRenderEnt = head.GetEntity()->GetRenderEntity();
	} else {
		headRenderEnt = NULL;
	}

	if ( gameLocal.isMultiplayer || g_showPlayerShadow.GetBool() ) {
		renderEntity.suppressShadowInViewID	= 0;
		if ( headRenderEnt ) {
			headRenderEnt->suppressShadowInViewID = 0;
		}
	} else {
		renderEntity.suppressShadowInViewID	= entityNumber+1;
		if ( headRenderEnt ) {
			headRenderEnt->suppressShadowInViewID = entityNumber+1;
		}
	}
	// never cast shadows from our first-person muzzle flashes
	renderEntity.suppressShadowInLightID = LIGHTID_VIEW_MUZZLE_FLASH + entityNumber;
	if ( headRenderEnt ) {
		headRenderEnt->suppressShadowInLightID = LIGHTID_VIEW_MUZZLE_FLASH + entityNumber;
	}

	if ( !g_stopTime.GetBool() ) {
		UpdateAnimation();
		Present();
		UpdateDamageEffects();
		if (gameLocal.isMultiplayer) { //rww
			UpdateWounds();
		}
		LinkCombat();
		playerView.CalculateShake();
	}

	if ( g_showEnemies.GetBool() ) {
		idActor *ent;
		int num = 0;
		for( ent = enemyList.Next(); ent != NULL; ent = ent->enemyNode.Next() ) {
			gameLocal.Printf( "enemy (%d)'%s'\n", ent->entityNumber, ent->name.c_str() );
			gameRenderWorld->DebugBounds( colorRed, ent->GetPhysics()->GetBounds().Expand( 2 ), ent->GetPhysics()->GetOrigin() );
			num++;
		}
		gameLocal.Printf( "%d: enemies\n", num );
	}
}

/*
==============
hhPlayer::AdjustBodyAngles
==============
*/
void hhPlayer::AdjustBodyAngles( void ) {
	if (InVehicle()) {
		return;
	}

	if (bClampYaw) { //rww - for slabs
		//first, clamp the viewangles while bound to a slab
		if (maxRelativePitch >= 0.0f) {
			if (untransformedViewAngles.pitch > maxRelativePitch) {
				untransformedViewAngles.pitch = maxRelativePitch;
				SetViewAngles(untransformedViewAngles);
			}
			else if (untransformedViewAngles.pitch < -maxRelativePitch) {
				untransformedViewAngles.pitch = -maxRelativePitch;
				SetViewAngles(untransformedViewAngles);
			}
		}

		animator.SetJointAxis( hipJoint, JOINTMOD_WORLD, mat3_identity ); //no leg offset while slabbed

#if 0 //old headlook code
		if (head.IsValid() && head.GetEntity()) { //has a head
			idVec3 origin;
			idMat3 axis;

			head->GetPhysics()->Evaluate(gameLocal.time-gameLocal.previousTime, gameLocal.time); //make sure it is bolted up to date

			if (GetMasterPosition(origin, axis)) {
				idAngles masterAngles = axis.ToAngles(); //bound angles
				idAngles ang;
				idMat3 rot;

				//determine our "look" angles
				ang.yaw = viewAngles.yaw-masterAngles.yaw;
				ang.pitch = viewAngles.pitch;
				ang.roll = 0.0f;

				ang = ang.Normalize180();
				ang *= 0.5f; //scale the angles down so the head doesn't go completely sideways or anything

				//set the yaw only
				animator.SetJointAxis(headJoint, JOINTMOD_WORLD, idAngles(0.0f, ang.yaw, 0.0f).ToMat3());
				ang.yaw = 0.0f;

				hhMath::BuildRotationMatrix(DEG2RAD(-ang.pitch), 0, rot); //create a rotation matrix for the pitch

				//get the local axis to multiply it by the pitch rotation matrix
				animator.GetJointLocalTransform(headJoint, gameLocal.time, origin, axis);

				//use the multiplied axis
				animator.SetJointAxis(headJoint, JOINTMOD_LOCAL, rot*axis); //point head in proper direction
			}
		}
#endif
	}
	else {
#if 0 //old headlook code
		//rww - reset head joint override when not on a slab
		animator.SetJointAxis( headJoint, JOINTMOD_LOCAL, idAngles( 0.0f, 0.0f, 0.0f ).ToMat3() );
#endif
		idPlayer::AdjustBodyAngles();
	}
}

/*
==============
hhPlayer::Move
	PDMMERGE PERSISTENTMERGE: Overridden, Done for 6-03-05 merge
==============
*/
void hhPlayer::Move( void ) {
	float newEyeOffset;
	idVec3 oldOrigin;
	idVec3 oldVelocity;
	idVec3 pushVelocity;

	// save old origin and velocity for crashlanding
	oldOrigin = physicsObj.GetOrigin();
	oldVelocity = physicsObj.GetLinearVelocity();
	pushVelocity = physicsObj.GetPushedLinearVelocity();

	// set physics variables
	physicsObj.SetMaxStepHeight( GetStepHeight() );//HUMANHEAD: aob
	physicsObj.SetMaxJumpHeight( pm_jumpheight.GetFloat() );

	if ( noclip ) {
		physicsObj.SetContents( 0 );
		physicsObj.SetMovementType( PM_NOCLIP );
	} else if ( spectating ) {
		physicsObj.SetContents( 0 );
		physicsObj.SetMovementType( PM_SPECTATOR );
	} else if ( bInDeathwalkTransition ) {		// In between life and death, don't allow ragdoll to collide with player
		physicsObj.SetContents( 0 );
		physicsObj.SetMovementType( PM_NORMAL );
	} else if ( IsDead() ) { 					// HUMANHEAD cjr:  Replaced health <= 0 with IsDead() call for deathwalk override
		if (gameLocal.isMultiplayer) {			// HUMANHEAD rww - contents 0 because we use a dead body proxy in mp
			physicsObj.SetContents(0);
		}
		else {
			physicsObj.SetContents( CONTENTS_CORPSE | CONTENTS_MONSTERCLIP );
		} //HUMANHEAD END
		physicsObj.SetMovementType( PM_DEAD );	
	} else if ( gameLocal.inCinematic || gameLocal.GetCamera() || privateCameraView ) {
		physicsObj.SetContents( CONTENTS_BODY );
		physicsObj.SetMovementType( PM_FREEZE );
	} else if ( bFrozen && !IsSpiritOrDeathwalking() ) {		// HUMANHEAD: freeze support
		physicsObj.SetContents( CONTENTS_BODY );
		physicsObj.SetMovementType( PM_FREEZE );
	} else {
		physicsObj.SetContents( CONTENTS_BODY );
		physicsObj.SetMovementType( PM_NORMAL );
	}

	if ( spectating ) {
		physicsObj.SetClipMask( MASK_SPECTATOR );
	} else if ( IsDead() ) {	// HUMANHEAD cjr:  Replaced health <= 0 with IsDead() call for deathwalk override
		physicsObj.SetClipMask( MASK_DEADSOLID );
	// HUMANHEAD cjr: allow spirit walk
	} else if ( IsSpiritOrDeathwalking() ) {
		physicsObj.SetClipMask( MASK_SPIRITPLAYER );
	// HUMANHEAD END
	} else {
		physicsObj.SetClipMask( MASK_PLAYERSOLID );
	}

	physicsObj.SetDebugLevel( g_debugMove.GetBool() );
	physicsObj.SetPlayerInput( usercmd, viewAngles );

	//HUMANHEAD: aob - moved down a few lines
	// FIXME: physics gets disabled somehow
	//BecomeActive( TH_PHYSICS );
	//RunPhysics();
	//HUMANHEAD END

	// update our last valid AAS location for the AI
	SetAASLocation();

	if ( spectating ) {
		newEyeOffset = 0.0f;
	// HUMANHEAD cjr:  Replaced health <= 0 with IsDead() call for deathwalk override
	} else if ( IsDead() ) {
		newEyeOffset = pm_deadviewheight.GetFloat();
	} else if ( physicsObj.IsCrouching() ) {
		newEyeOffset = pm_crouchviewheight.GetFloat();
	} else if ( GetBindMaster() && GetBindMaster()->IsType( idAFEntity_Vehicle::Type ) ) {
		newEyeOffset = 0.0f;
	} else {
		newEyeOffset = pm_normalviewheight.GetFloat();
	}

	if ( EyeHeight() != newEyeOffset ) {
		//AOB: camera does smoothing
		SetEyeHeight( newEyeOffset );
	}

	// HUMANHEAD aob 
	float camRotScale = p_camRotRateScale.GetFloat();
	//rww - if on a wallwalk mover, increase the scale
	if (GetPhysics() == &physicsObj && physicsObj.GetGroundTrace().fraction < 1.0f) {
		const trace_t &grTr = physicsObj.GetGroundTrace();
		if (grTr.c.entityNum >= 0 && grTr.c.entityNum < MAX_GENTITIES && gameLocal.entities[grTr.c.entityNum] && gameLocal.entities[grTr.c.entityNum]->IsType(hhMover::Type) && grTr.c.material && grTr.c.material->GetSurfaceType() == SURFTYPE_WALLWALK) {
			camRotScale *= 5.0f;
		}
	}
	cameraInterpolator.Setup( camRotScale, IT_VariableMidPointSinusoidal );//Also set in constructor

	// moved here to allow weapons physics get correct eyeOffset
	BecomeActive( TH_PHYSICS ); //rww - prevent the bug that id so lovingly left for us
	RunPhysics();
	// HUMANHEAD END

	// HUMANHEAD pdm: Experimental: allow player to jump up onto wallwalk
#define WALLWALK_EXPERIMENT 0
#if WALLWALK_EXPERIMENT
	if (!physicsObj.IsWallWalking() && physicsObj.HasJumped()) {
		trace_t trace;
		memset(&trace, 0, sizeof(trace));
		idVec3 start, end;
		start = physicsObj.GetOrigin();
		end = start + idVec3(0,0,100);	//fixme: jumpheight
		if (gameLocal.clip.TracePoint( trace, start, end, MASK_SOLID, this )) {
			if (gameLocal.GetMatterType(trace, NULL) == SURFTYPE_WALLWALK) {
				gameLocal.Printf("Trying to flip over for wallwalk\n");

				// Clear velocity, so won't miss wallwalk above
				physicsObj.SetLinearVelocity(vec3_origin);

				SetGravity(-trace.c.normal * DEFAULT_GRAVITY);
				ProcessEvent( &EV_ShouldRemainAlignedToAxial, (int)false );
				ProcessEvent( &EV_OrientToGravity, (int)true );

				physicsObj.IsWallWalking( true );

/*				idVec3 flippedOrigin = trace.endpos;
				idMat3 flippedAxis;
				flippedAxis[0] = GetAxis()[0];
				flippedAxis[2] = trace.c.normal;
				flippedAxis[1] = flippedAxis[0].Cross(flippedAxis[2]);

//				cameraInterpolator.SetInterpolationType(flags);
//				cameraInterpolator.SetTargetEyeOffset(idealEyeOffset, flags);
//				cameraInterpolator.SetTargetPosition(idealPosition, flags);

				// Flip the physics object
				physicsObj.SetOrigin(flippedOrigin);
				physicsObj.SetAxis(flippedAxis);
				physicsObj.CheckWallWalk(true);*/
			}
		}
	}
#endif
	// HUMANHEAD END

	if ( noclip || gameLocal.inCinematic ) {
		AI_CROUCH	= false;
		AI_ONGROUND	= false;
		AI_ONLADDER	= false;
		AI_JUMP		= false;
		AI_REALLYFALL = true; //HUMANHEAD rww - well, it fits with ONGROUND false
	} else {
		AI_CROUCH	= physicsObj.IsCrouching();
		AI_ONGROUND	= physicsObj.HasGroundContacts();
		AI_ONLADDER	= physicsObj.OnLadder();
		AI_JUMP		= physicsObj.HasJumped();
		//HUMANHEAD rww
		if (!physicsObj.IsInwardGravity()) {
			AI_REALLYFALL = !AI_ONGROUND;
		}
		else if (!AI_ONGROUND) { //for inward gravity zones, do an extra ground check when in-air
			AI_REALLYFALL = !physicsObj.ExtraGroundCheck();
		}
		//HUMANHEAD END

		// check if we're standing on top of a monster and give a push if we are
		idEntity *groundEnt = physicsObj.GetGroundEntity();
		if ( groundEnt && groundEnt->IsType( idAI::Type ) ) {
			idVec3 vel = physicsObj.GetLinearVelocity();
			if ( vel.ToVec2().LengthSqr() < 0.1f ) {
				vel.ToVec2() = physicsObj.GetOrigin().ToVec2() - groundEnt->GetPhysics()->GetAbsBounds().GetCenter().ToVec2();
				vel.ToVec2().NormalizeFast();
				vel.ToVec2() *= pm_walkspeed.GetFloat();
			} else {
				// give em a push in the direction they're going
				vel *= 1.1f;
			}
			physicsObj.SetLinearVelocity( vel );
		}
	}

	if ( AI_JUMP ) {
		// bounce the view weapon
		loggedAccel_t	*acc = &loggedAccel[currentLoggedAccel&(NUM_LOGGED_ACCELS-1)];
		currentLoggedAccel++;
		acc->time = gameLocal.time;
		acc->dir[2] = 200;
		acc->dir[0] = acc->dir[1] = 0;
	}

	BobCycle( pushVelocity );
	if ( !noclip ) { // HUMANHEAD: Only crashland if not spiritwalking or not deathwalking
		CrashLand( oldOrigin, oldVelocity );
	}

	//HUMANHEAD: aob - put this into helper func
	if (!gameLocal.isClient) {
		if( IsWallWalking() && !WasWallWalking() ) {
			wallwalkSoundController.StartSound( SND_CHANNEL_WALLWALK, SND_CHANNEL_WALLWALK2, SSF_LOOPING, false );
		} else if( !IsWallWalking() && WasWallWalking() ) {
			wallwalkSoundController.StopSound( SND_CHANNEL_WALLWALK, SND_CHANNEL_WALLWALK2, false );
		}
	}
	physicsObj.WasWallWalking( IsWallWalking() ); //rww - moved here
	//HUMANHEAD END
}

/*
===============
hhPlayer::ShouldTouchTrigger
===============
*/
bool hhPlayer::ShouldTouchTrigger( idEntity* entity ) const {
	if( !entity ) {
		return false;
	}

	if ( entity->fl.onlySpiritWalkTouch ) { // cjr - Trigger can only be touched by spirit
		return IsSpiritWalking();
	}

	if( IsSpiritOrDeathwalking() && !entity->fl.allowSpiritWalkTouch ) { // Trigger can be touched by either physical or spirit
		return false; // jrm - reversed logic
	}

	return true;
}

/*
===============
hhPlayer::HandleSingleGuiCommand
===============
*/
bool hhPlayer::HandleSingleGuiCommand(idEntity *entityGui, idLexer *src) {

	idToken token;

	if (!src->ReadToken(&token)) {
		return false;
	}

	if (token == ";") {
		return false;
	}

	if (token.Icmp("guilockplayer") == 0) {
		//Now locked in place:
		// manglecontrols() will route controls to current gui focus
		if (entityGui->IsType(hhConsole::Type)) {
			guiWantsControls = static_cast<hhConsole*>(entityGui);
		}
		return true;
	}

	src->UnreadToken(&token);
	return idPlayer::HandleSingleGuiCommand(entityGui, src);
}

void hhPlayer::SetOverlayGui(const char *guiName) {
	if (guiName && *guiName && guiOverlay == NULL) {
		guiOverlay = uiManager->FindGui(guiName, true);
		if (guiOverlay) {
			guiOverlay->Activate(true, gameLocal.time);
		}
	}
	else {
		guiOverlay = NULL;
	}
}

/*
============
hhPlayer::ForceWeapon
nla: used to instantly force the spirit weapon, without lowering and raising
============
*/
void hhPlayer::ForceWeapon( int weaponNum ) {
	const char *		weaponDef;
	hhWeapon *			newWeapon;

	if (spectating) { //rww - if spectating this is bad.
		gameLocal.Error("hhPlayer::ForceWeapon called on spectator. (client %i)", entityNumber);
	}

	// HUMANHEAD mdl:  Special case - coming out of spirit mode when no physical weapon is available
	if ( weaponNum == -1 ) {
		idealWeapon = 0;
		currentWeapon = -1;
		return;
	}

	if ( weaponNum < 1 ) {
		gameLocal.Warning( "Error: Illegal weapon num passed: %d\n", weaponNum );
	}

	weaponDef = GetWeaponName( weaponNum );

	newWeapon = SpawnWeapon( weaponDef );

	weapon = newWeapon;

	idealWeapon = currentWeapon = weaponNum;

	animPrefix = weaponDef;
	animPrefix.Strip( "weaponobj_" );
}


/*
============
hhPlayer::ForceWeapon
============
*/
void hhPlayer::ForceWeapon( hhWeapon *newWeapon ) {
	int weaponNum;


	weapon = newWeapon;

	weaponNum = GetWeaponNum( weapon->GetDict()->GetString( "classname" ) );

	idealWeapon = currentWeapon = weaponNum;

}

/*
===========
hhPlayer::Teleport

HUMANHEAD cjr:  Now calls TeleportNoKillBox, then applies a kill box
============
*/
void hhPlayer::Teleport( const idVec3& origin, const idAngles& angles, idEntity *destination ) {
	//pdm - converted this to call our other version so it doesn't unalign the clip model
	TeleportNoKillBox( origin, mat3_identity, angles.ToForward(), angles );

	// mdl:  Moved here from TeleportNoBox, so player can't avoid falling damage by toggling spirit mode quickly
	physicsObj.SetLinearVelocity( vec3_origin );
	physicsObj.SetKnockBack( 250 ); // Slow the player down after a teleport for a moment

	// kill anything at the new position
	gameLocal.KillBox( this, destination != NULL );

	teleportEntity = destination;
}

/*
===========
hhPlayer::Teleport

HUMANHEAD aob:  Needed for coming back from deathwalk
============
*/
void hhPlayer::Teleport( const idVec3& origin, const idMat3& bboxAxis, const idVec3& viewDir, const idAngles& newUntransformedViewAngles, idEntity *destination ) {
	TeleportNoKillBox( origin, bboxAxis, viewDir, newUntransformedViewAngles );

	// kill anything at the new position
	gameLocal.KillBox( this, destination != NULL );

	teleportEntity = destination;
}

/*
===========
hhPlayer::TeleportNoKillBox

HUMANHEAD cjr:  Called from SpiritProxy
============
*/
void hhPlayer::TeleportNoKillBox( const idVec3& origin, const idMat3& bboxAxis, const idVec3& viewDir, const idAngles& newUntransformedViewAngles ) {
	DisableIK();

	SetOrientation( origin, bboxAxis, viewDir, newUntransformedViewAngles );

	CancelEvents( &EV_ResetGravity );
	ProcessEvent( &EV_ResetGravity ); // Guarantee that gravity is instantly reset after this teleport

	EnableIK();
}

/*
===========
hhPlayer::TeleportNoKillBox

HUMANHEAD cjr: Teleport, but don't telefrag anything
============
*/

void hhPlayer::TeleportNoKillBox( const idVec3& origin, const idMat3& bboxAxis ) {
	TeleportNoKillBox( origin, bboxAxis, GetAxis()[0], GetUntransformedViewAngles() );
}

/*
=====================
hhPlayer::Possess

//HUMANHEAD: cjr - this is the entry point for possession.
=====================
*/
void hhPlayer::Possess( idEntity* possessor ) {
	bPossessed = true;
	
	/* TODO:
		- needs a new spirit proxy (a little hidden object just as storage that is linked to the possessed human)
		- disallow the player from returning until the possessed tommy has been "killed"
			

		possessed tommy:
		- attacks whatever
		- health ticking down -- when it reaches zero, ragdoll and instantly kill the spirit player
		- if killed by the spirit bow, then the wraith is removed (seperate health?)
	*/

	// If we're spirit walking when we're possessed, snap back to our body for a moment, then get thrown back out.
	//TODO this isn't ideal
	if ( IsSpiritOrDeathwalking() ) {
		DisableEthereal();
	}

	// Must allow spirit walking at this point
	HH_ASSERT( bAllowSpirit );

	// Force the player into spirit and thrust them backwards
	StartSpiritWalk( true, true );

	// test:  spawn in a possessed version
	// need: effects here...flash or whatever
	possessedTommy = (hhPossessedTommy *)gameLocal.SpawnObject( "monster_possessed_tommy", NULL );

	if ( possessedTommy.IsValid() ) { // Copy player stats to the possessed Tommy
		/*if ( IsSpiritOrDeathwalking() ) { //TODO mdl:  Remove this if we go with wraiths knocking players back to their body
			// This should means we were called by 
			possessedTommy->SetOrigin( spiritProxy->GetOrigin() );
			possessedTommy->SetAxis( spiritProxy->GetAxis() );
		} else*/ {
			possessedTommy->SetOrigin( GetOrigin() );
			possessedTommy->SetAxis( GetAxis() );
		}
		possessedTommy->SetPossessedProxy( spiritProxy.GetEntity() );
	}
}

/*
=====================
hhPlayer::Unpossess

//HUMANHEAD: cjr
=====================*/

void hhPlayer::Unpossess() {
	bPossessed = false;

	possessedTommy = NULL;
/*
	idDict		args;
	idEntity	*ent;

	playerView.SetViewOverlayMaterial( NULL );
	possessionFOV = 0; // Restore the original FOV

	// Spawn a wraith to fly out of the player's origin
	args.Clear();
	args.SetVector( "origin", GetOrigin() + GetEyePosition() + GetAxis()[0] * 50 );
	args.SetMatrix( "rotation", GetAxis() );
//TODO: Externalize this monster_wraith
	args.Set( "classname", "monster_wraith" );

	gameLocal.SpawnEntityDef( args, &ent );
	((hhWraith *)ent)->SetEnemy( this );

	// TODO: Unpossessed by portalling, so kill the wraith
*/
}

//=============================================================================
//
// hhPlayer::CanBePossessed
//
// Players can only be possessed if they are are not currently possessed
//=============================================================================

bool hhPlayer::CanBePossessed( void ) {
	if ( godmode || noclip || !bAllowSpirit ) { // Don't possess if in god mode or noclipping
		return false;
	}

	return !(IsPossessed() || InVehicle() || IsSpiritOrDeathwalking() );
}

//=============================================================================
//
// hhPlayer::PossessKilled
//
// Killed when possessed (spirit power ran out)
// 
// - Ragdoll the possessed body
// - Return to the location of the possessed tommy and die
//=============================================================================

void hhPlayer::PossessKilled( void ) {
	if ( possessedTommy.IsValid() ) {
		possessedTommy->PostEventMS( &EV_Remove, 0 );
	}

	Unpossess();
	StopSpiritWalk();
	Kill( 0, 0 ); // FIXME:  Some other way to kill self (instead of suicide?)
}

//=============================================================================
//
// hhPlayer::Portalled
//
// Player just portalled
//=============================================================================

void hhPlayer::Portalled( idEntity *portal ) {
	if ( talon.IsValid() && talon->GetBindMaster() != this ) { // If Talon isn't bound to Tommy, portal him with the player
		talon->Portalled( portal );
	}

	if (gameLocal.isClient) { //HUMANHEAD rww - compensate for angle jump
		bBufferNextSnapAngles = true;
		smoothedAngles = viewAngles;
	}
	smoothedFrame = 0; //HUMANHEAD rww - skip smoothing on the portalled frame
	walkIK.InvalidateHeights(); //HUMANHEAD rww - don't try to interpolate ik positions between two equal planes on either side of a portal
	if (gameLocal.isServer) { //HUMANHEAD rww - send an unreliable event in the coming snapshot
		idBitMsg	msg;
		byte		msgBuf[MAX_EVENT_PARAM_SIZE];

		msg.Init(msgBuf, sizeof(msgBuf));
		msg.WriteBits(gameLocal.GetSpawnId(portal), 32);
		ServerSendEvent(EVENT_PORTALLED, &msg, false, -1, -1, true); //only send it to the client who portalled
	}
}

/*
================
hhPlayer::UpdateModelTransform
================
*/
void hhPlayer::UpdateModelTransform( void ) {
	idVec3 origin;
	idMat3 axis;

	if( GetPhysicsToVisualTransform(origin, axis) ) {
		//HUMANHEAD: aob
		GetRenderEntity()->axis = axis;
		idVec3 absOrigin = TransformToPlayerSpaceNotInterpolated( origin ); //rww - don't use interpolated origin
		GetRenderEntity()->origin = absOrigin;
		//HUMANHEAD END
	} else {
		//HUMANHEAD: aob
		GetRenderEntity()->axis = GetAxis();
		GetRenderEntity()->origin = GetOrigin();
		//HUMANHEAD END
	}
}

/*
====================
hhPlayer::CalcFov

Fixed fov at intermissions, otherwise account for fov variable and zooms.
Takes possession FOV into account

HUMANHEAD cjr
====================
*/
float hhPlayer::CalcFov( bool honorZoom ) {
	float	fov;

	// HUMANHEAD mdl:  Refactored this to work properly with possessionFOV.  Being zoomed in will ignore possessionFOV, however.
	idEntity *weaponEnt = weapon.GetEntity();
	if ( possessionFOV > 0.0f && 
		 ! ( weaponEnt &&
			 weaponEnt->IsType( hhWeaponZoomable::Type ) &&
			 reinterpret_cast<hhWeaponZoomable *> (weaponEnt)->IsZoomed() ) )
	{
		fov = possessionFOV;
	} else if ( IsDeathWalking() ) {
		fov = spawnArgs.GetFloat("deathwalkFOV", "90");
	} else if ( pm_thirdPerson.GetBool() ) {
		fov = g_fov.GetFloat();
	} else if ( InCinematic() ) {
		fov = cinematicFOV.GetCurrentValue(gameLocal.time);
	} else {
		fov = zoomFov.GetCurrentValue(gameLocal.time);
	}

	//HUMANHEAD: aob
	fov = hhMath::ClampFloat( 1.0f, 179.0f, fov );
	//HUMANHEAD END

	return fov;
}

/*
===============
hhPlayer::EnterVehicle
===============
*/
void hhPlayer::EnterVehicle( hhVehicle* vehicle ) {
	if (!gameLocal.isClient) { //HUMANHEAD PCF rww 05/04/06 - do not do the check on the client, just listen to what the snapshot says.
		if (!vehicle->WillAcceptPilot(this)) {
			return;
		}
	}

	// Cancel any pending damage allowing events, since we'll be turning damage off
	CancelEvents(&EV_AllowDamage);

	// Set shuttle view
	if (entityNumber == gameLocal.localClientNum) { //rww
		renderSystem->SetShuttleView( true );
	}

	// Move eye to proper height
	SetEyeHeight( vehicle->spawnArgs.GetFloat("pilot_eyeHeight") );

	// Turn off any illegal behaviors
	if( IsSpiritWalking() ) {
		StopSpiritWalk();
	}

	LighterOff();

	// nla - Remove any offset cause by jumping.  (Fixes the jumping and getting in the shuttle bug)
	SetViewBob( vec3_origin );

	// CJR: Inform Talon that the player has entered a vehicle
	if( talon.IsValid() ) {
		talon->OwnerEnteredVehicle();
	}

	ShouldRemainAlignedToAxial( false );

	cameraInterpolator.SetInterpolationType( IT_None );
	SetOrientation( GetOrigin(), mat3_identity, vehicle->GetAxis()[0], vehicle->GetAxis()[0].ToAngles() );
	//Need to clear untransformedViewAxis so cameraInterpolator doesn't do any unnessacary transforms
	SetUntransformedViewAxis( mat3_identity );

	//Hack
	cameraInterpolator.Reset( GetOrigin(), mat3_identity[2], EyeHeightIdeal() );

	idPlayer::EnterVehicle( vehicle );
}

/*
===============
hhPlayer::ExitVehicle

This should only be called from vehicle
===============
*/
void hhPlayer::ExitVehicle( hhVehicle* vehicle ) {

	// Allow model in player's view again
	if (vehicle) {
		vehicle->GetRenderEntity()->suppressSurfaceInViewID = 0;
	}

	// Set shuttle view off
	if (entityNumber == gameLocal.localClientNum) { //rww
		renderSystem->SetShuttleView( false );
	}

	ShouldRemainAlignedToAxial( true );

	// CJR: Inform Talon that the player has left a vehicle
	if( talon.IsValid() ) {
		talon->OwnerExitedVehicle();
	}

	idPlayer::ExitVehicle( vehicle );

	buttonMask |= BUTTON_ATTACK_ALT;	//HUMANHEAD bjk

	// Reset the animPrefix
	animPrefix = spawnArgs.GetString( va( "def_weapon%d", currentWeapon ) );
	animPrefix.Strip( "weaponobj_" );

	if (vehicle) {
		SetOrientation( GetOrigin(), mat3_identity, vehicle->GetAxis()[0], vehicle->GetAxis()[0].ToAngles().Normalize180() );
	}
	cameraInterpolator.SetInterpolationType( IT_VariableMidPointSinusoidal );
}

//
// ResetClipModel()
//
// HUMANHEAD: aob
//
void hhPlayer::ResetClipModel() {
	//Needed for touching triggers.  Our bbox is its original size.
	SetClipModel();
}

/*
===============
hhPlayer::BecameBound
===============
*/
void hhPlayer::BecameBound(hhBindController *b) {
	if( !gameLocal.isMultiplayer && weapon.IsValid() ) { //rww - can use weapon while bound in mp
		weapon->Hide();
	}
}

/*
===============
hhPlayer::BecameUnbound
===============
*/
void hhPlayer::BecameUnbound(hhBindController *b) {
	if( !gameLocal.isMultiplayer && weapon.IsValid() ) { //rww - can use weapon while bound in mp
		weapon->Show();
	}
}

void hhPlayer::GetLocationText( idStr &locationString ) {
	idLocationEntity* locationEntity = gameLocal.LocationForPoint( GetEyePosition() );
	if( locationEntity ) {
		locationString = locationEntity->GetLocation();
	}
	else {
		locationString = common->GetLanguageDict()->GetString( "#str_02911" );
	}
}

void hhPlayer::UpdateLocation( void ) {
	if( hud ) {
		hud->SetStateBool("showlocations", developer.GetBool());
		if (developer.GetBool()) {
			idStr locationString;
			GetLocationText(locationString);
			hud->SetStateString( "location", locationString.c_str() );
			hud->SetStateInt( "areanum", gameRenderWorld->PointInArea( GetEyePosition() ));
		}
	}
}

/*
===============
hhPlayer::FillDebugVars
===============
*/
void hhPlayer::FillDebugVars(idDict *args, int page) {
	idStr text;

	switch(page) {
	case 1:
		args->SetInt("deathpower", GetDeathWalkPower());
		args->SetInt("spiritpower", GetSpiritPower());
		args->SetBool("AI_CROUCH", AI_CROUCH != 0);
		args->SetBool("AI_ONGROUND", AI_ONGROUND != 0);
		args->SetBool("AI_JUMP", AI_JUMP != 0);
		args->SetBool("AI_SOFTLANDING", AI_SOFTLANDING != 0);
		args->SetBool("AI_HARDLANDING", AI_HARDLANDING != 0);
		args->SetBool("AI_FORWARD", AI_FORWARD != 0);
		args->SetBool("AI_BACKWARD", AI_BACKWARD != 0);
		args->SetBool("AI_STRAFE_LEFT", AI_STRAFE_LEFT != 0);
		args->SetBool("AI_STRAFE_RIGHT", AI_STRAFE_RIGHT != 0);
		args->SetBool("AI_ATTACK_HELD", AI_ATTACK_HELD != 0);
		args->SetBool("AI_WEAPON_FIRED", AI_WEAPON_FIRED != 0);
		args->SetBool("AI_JUMP", AI_JUMP != 0);
		args->SetBool("AI_DEAD", AI_DEAD != 0);
		args->SetBool("AI_PAIN", AI_PAIN != 0);
		args->SetBool("AI_RELOAD", AI_RELOAD != 0);
		args->SetBool("AI_TELEPORT", AI_TELEPORT != 0);
		args->SetBool("AI_TURN_LEFT", AI_TURN_LEFT != 0);
		args->SetBool("AI_TURN_RIGHT", AI_TURN_RIGHT != 0);
		args->SetBool("AI_ASIDE", AI_ASIDE != 0);
		args->SetBool("AI_REALLYFALL", AI_REALLYFALL != 0); //HUMANHEAD rww
		args->SetBool("HasGroundContacts", physicsObj.HasGroundContacts());
		args->Set("animPrefix", animPrefix.c_str());
		break;
	case 2:
		args->Set("Physics Axis", GetPhysics()->GetAxis().ToAngles().ToString());
		args->Set("viewAxis", viewAxis.ToAngles().ToString());
		args->Set("cmdAngles", cmdAngles.ToString());
		args->Set("deltaViewAngles", GetDeltaViewAngles().ToString() );
		args->Set("viewAngles", viewAngles.ToString());
		args->Set("untransAngles", GetUntransformedViewAngles().ToString());
		args->Set("xPhysics Axis", GetPhysics()->GetAxis().ToString());
		args->Set("xviewAxis", viewAxis.ToString());
		args->Set("idealLegsYaw", va("%.1f", idealLegsYaw));
		args->SetInt("usercmd.forwardmove", usercmd.forwardmove);
		args->SetInt("usercmd.rightmove", usercmd.rightmove);
		args->SetInt("legsForward", legsForward);

		switch(physicsObj.GetWaterLevel()) {
			case WATERLEVEL_NONE:	text = "none"; break;
			case WATERLEVEL_FEET:	text = "feet"; break;
			case WATERLEVEL_WAIST:	text = "waist"; break;
			case WATERLEVEL_HEAD:	text = "head"; break;
		}
		args->Set("waterlevel", text);
		text = collisionModelManager->ContentsName(physicsObj.GetWaterType());
		args->Set("watertype", text);
		break;
	case 3:
		break;
	}
	idPlayer::FillDebugVars(args, page);
}

//
// GetAimPosition()
//
idVec3 hhPlayer::GetAimPosition() const {
	return GetEyePosition();
}

/*
===============
hhPlayer::WriteToSnapshot
===============
*/
void hhPlayer::WriteToSnapshot( idBitMsgDelta &msg ) const {
	bool vehControlling = vehicleInterfaceLocal.ControllingVehicle();

	msg.WriteBits(vehControlling, 1);

	//rww - our stuff is now intermingled with id's for more ideal send ordering
	physicsObj.WriteToSnapshot( msg, vehControlling );

	if (!vehControlling) {
		//not syncing these causes denormalization/nan issues, FIXME
		msg.WriteFloat(untransformedViewAngles[0]);
		msg.WriteFloat(untransformedViewAngles[1]);
		msg.WriteFloat(untransformedViewAngles[2]);
		idCQuat q = untransformedViewAxis.ToCQuat();
		msg.WriteFloat(q.x);
		msg.WriteFloat(q.y);
		msg.WriteFloat(q.z);

		//rww - write cameraInterpolator
		cameraInterpolator.WriteToSnapshot(msg, this);

		//still need delta angles
		//msg.WriteDeltaFloat( 0.0f, deltaViewAngles[0] );
		//msg.WriteDeltaFloat( 0.0f, deltaViewAngles[1] );
		//msg.WriteDeltaFloat( 0.0f, deltaViewAngles[2] );
	}
#if 0 //for debugging differences in snapshot
	else {
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);

		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteFloat(0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteFloat(0.0f, 4, 4);

		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteFloat(0.0f, 4, 4);

		msg.WriteFloat(0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteFloat(0.0f, 4, 4);

		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
		msg.WriteDeltaFloat(0.0f, 0.0f);
	}
#endif

	msg.WriteDeltaFloat( 0.0f, deltaViewAngles[0] );
	msg.WriteDeltaFloat( 0.0f, deltaViewAngles[1] );
	msg.WriteDeltaFloat( 0.0f, deltaViewAngles[2] );

	msg.WriteShort( health );
	msg.WriteBits( gameLocal.ServerRemapDecl( -1, DECL_ENTITYDEF, lastDamageDef ), gameLocal.entityDefBits );
	msg.WriteDir( lastDamageDir, 9 );
	msg.WriteShort( lastDamageLocation );
	msg.WriteBits( idealWeapon, idMath::BitsForInteger( MAX_WEAPONS ) );
	msg.WriteBits( inventory.weapons, MAX_WEAPONS );
	msg.WriteBits( weapon.GetSpawnId(), 32 );
	msg.WriteBits( spectator, idMath::BitsForInteger( MAX_CLIENTS ) );
	msg.WriteBits( lastHitToggle, 1 );
	msg.WriteBits( weaponGone, 1 );
	WriteBindToSnapshot( msg );
//===================END OF ID DATA
	msg.WriteShort(inventory.maxHealth); //rww - since maxhealth can go above 100 in mp now

	msg.WriteBits( spiritProxy.GetSpawnId(), 32 );

	//rww - more spiritwalk stuff
	msg.WriteBits(lastWeaponSpirit, 32);
	msg.WriteBits(bSpiritWalk, 1);

	//not needed anymore
	/*
	msg.WriteBits( bShowProgressBar, 1 );
	msg.WriteFloat( progressBarValue );
	msg.WriteBits( progressBarState, 2 );	// possible values [0..2]
	*/

	//rww - send ammo for current weapon - this is because our weapon routines rely on if we have ammo
	//in scripts and so on, and will be predicted wrong for other players (we get our own ammo in the playerstate)
	//rwwFIXME: if we have proper weapon switching when you run out of ammo will this actually be necessary?
	//i don't think it's all that costly, but still.
	if (weapon.IsValid()) {
		ammo_t ammoType = weapon->GetAmmoType();
		if (ammoType > 0) {
			msg.WriteBits(inventory.ammo[ammoType], ASYNC_PLAYER_INV_AMMO_BITS);
		}
		else {
			msg.WriteBits(0, ASYNC_PLAYER_INV_AMMO_BITS);
		}
		ammoType = weapon->GetAltAmmoType();
		if (ammoType > 0) {
			msg.WriteBits(inventory.ammo[ammoType], ASYNC_PLAYER_INV_AMMO_BITS);
		}
		else {
			msg.WriteBits(0, ASYNC_PLAYER_INV_AMMO_BITS);
		}
	}
	else {
		msg.WriteBits(0, ASYNC_PLAYER_INV_AMMO_BITS);
		msg.WriteBits(0, ASYNC_PLAYER_INV_AMMO_BITS);
	}

	//need to sync buttonMask since we're using it for some state-based things
	msg.WriteBits(buttonMask, 8);

	msg.WriteFloat(EyeHeight());

	//HUMANHEAD PCF rww 05/04/06 - do not sync AI_VEHICLE, it is now based purely on the clientside
	//enter/exit of vehicles, with the vehControlling stack bool determining if we should be in a
	//vehicle on the client or not.
	//msg.WriteBits(AI_VEHICLE, 1);

	//rww - hand stuff
	//weaponHandState.WriteToSnapshot(msg);
	msg.WriteBits(hand.GetSpawnId(), 32);
	msg.WriteBits(handNext.GetSpawnId(), 32);

	//jsh - vehicle stuff
	msg.WriteBits( vehicleInterfaceLocal.GetVehicleSpawnId(), 32 );
	msg.WriteBits( vehicleInterfaceLocal.GetHandSpawnId(), 32 );
	//vehicleInterfaceLocal.GetWeaponHandState()->WriteToSnapshot(msg);

	//rww - lighter sync validation
	msg.WriteBits((lighterHandle != -1), 1);

	//rww - tractor
	msg.WriteBits(fl.isTractored, 1);

	spiritwalkSoundController.WriteToSnapshot(msg);
	//deathwalkSoundController.WriteToSnapshot(msg);
	wallwalkSoundController.WriteToSnapshot(msg);

	//HUMANHEAD rww - leechgun energy ammo
	//note - current weapon's ammo always sent now
	//ammo_t energyammo = hhWeaponFireController::GetAmmoType("ammo_energy");
	//msg.WriteBits(inventory.ammo[energyammo], ASYNC_PLAYER_INV_AMMO_BITS);
}

/*
===============
hhPlayer::ReadFromSnapshot
===============
*/
void hhPlayer::ReadFromSnapshot( const idBitMsgDelta &msg ) {
	int		i, oldHealth, newIdealWeapon, weaponSpawnId;
	bool	newHitToggle, stateHitch;

	bool vehControlling = !!msg.ReadBits(1);

	if ( snapshotSequence - lastSnapshotSequence > 1 ) {
		stateHitch = true;
	} else {
		stateHitch = false;
	}
	lastSnapshotSequence = snapshotSequence;

	oldHealth = health;

	physicsObj.ReadFromSnapshot( msg, vehControlling );

	if (!vehControlling) {
		//not syncing these causes denormalization/nan issues, FIXME
		if (bBufferNextSnapAngles) {
			idAngles n;
			n[0] = msg.ReadFloat();
			n[1] = msg.ReadFloat();
			n[2] = msg.ReadFloat();
			BufferLoggedViewAngles(n);
			untransformedViewAngles = n;
			bBufferNextSnapAngles = false;
		}
		else {
			untransformedViewAngles[0] = msg.ReadFloat();
			untransformedViewAngles[1] = msg.ReadFloat();
			untransformedViewAngles[2] = msg.ReadFloat();
		}
		idCQuat q;
		q.x = msg.ReadFloat();
		q.y = msg.ReadFloat();
		q.z = msg.ReadFloat();
		untransformedViewAxis = q.ToMat3();

		//rww - read cameraInterpolator
		cameraInterpolator.ReadFromSnapshot(msg, this);

		//deltaViewAngles[0] = msg.ReadDeltaFloat( 0.0f );
		//deltaViewAngles[1] = msg.ReadDeltaFloat( 0.0f );
		//deltaViewAngles[2] = msg.ReadDeltaFloat( 0.0f );
	}
#if 0 //for debugging differences in snapshot
	else {
		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadFloat();

		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadFloat();
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadFloat(4, 4);

		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadFloat(4, 4);

		msg.ReadFloat();
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadFloat(4, 4);

		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
		msg.ReadDeltaFloat(0.0f);
	}
#endif

	deltaViewAngles[0] = msg.ReadDeltaFloat( 0.0f );
	deltaViewAngles[1] = msg.ReadDeltaFloat( 0.0f );
	deltaViewAngles[2] = msg.ReadDeltaFloat( 0.0f );

	health = msg.ReadShort();
	lastDamageDef = gameLocal.ClientRemapDecl( DECL_ENTITYDEF, msg.ReadBits( gameLocal.entityDefBits ) );
	lastDamageDir = msg.ReadDir( 9 );
	lastDamageLocation = msg.ReadShort();
	newIdealWeapon = msg.ReadBits( idMath::BitsForInteger( MAX_WEAPONS ) );
	inventory.weapons = msg.ReadBits( MAX_WEAPONS );
	weaponSpawnId = msg.ReadBits( 32 );
	spectator = msg.ReadBits( idMath::BitsForInteger( MAX_CLIENTS ) );
	newHitToggle = msg.ReadBits( 1 ) != 0;
	weaponGone = msg.ReadBits( 1 ) != 0;
	ReadBindFromSnapshot( msg );

//===================END OF ID DATA

	inventory.maxHealth = msg.ReadShort(); //rww - since maxhealth can go above 100 in mp now

	idQuat quat;

	/*
	if( spiritProxy.SetSpawnId( msg.ReadBits( 32 ) ) ) {
		if (spiritProxy.GetEntity() && spiritProxy.GetEntity()->IsType(hhSpiritProxy::Type))
		{
			spiritProxy.GetEntity()->ActivateProxy( this, GetOrigin(), GetPhysics()->GetAxis(), viewAxis, viewAngles );
		}
	}*/
	spiritProxy.SetSpawnId( msg.ReadBits( 32 ) );

	//rww - more spiritwalk stuff
	lastWeaponSpirit = msg.ReadBits(32);
	
	bool spiritWalking = !!msg.ReadBits(1);
	if (spiritWalking != bSpiritWalk && (weapon.IsValid() || !spiritWalking)) {
		bSpiritWalk = spiritWalking;

		LighterOff(); //make sure lighter is off when switching spiritwalk

		if (bSpiritWalk) {
			if (gameLocal.localClientNum == entityNumber) {
				if (hud) {
					hud->HandleNamedEvent("SwitchToEthereal");
				}
				gameLocal.SpiritWalkSoundMode( true );
			}

			// Set the player's skin to a glowy effect
			SetSkinByName( spawnArgs.GetString("skin_Spiritwalk") );
			SetShaderParm( SHADERPARM_TIMEOFFSET, 1.0f ); // TEMP: cjr - Required by the forcefield material.  Can remove when a proper spiritwalk texture is made

			//put bow in proper state
			SelectEtherealWeapon();
		}
		else {
			if (gameLocal.localClientNum == entityNumber) {
				if (hud) {
					hud->HandleNamedEvent("SwitchFromEthereal");
				}
				gameLocal.SpiritWalkSoundMode( false );
			}

			SetSkinByName( NULL );
		}
	}

	//not needed anymore
	/*
	// Handle progress bar
	bool bBar = msg.ReadBits(1) != 0;
	float value = msg.ReadFloat();
	int state = msg.ReadBits(2);
	CL_UpdateProgress(bBar, value, state);
	*/

	// if not a local client assume the client has all ammo types
	if ( entityNumber != gameLocal.localClientNum ) {
		for( i = 0; i < AMMO_NUMTYPES; i++ ) {
			inventory.ammo[ i ] = 999;
		}
	}

	//rww - send ammo for current weapon - this is because our weapon routines rely on if we have ammo
	//in scripts and so on, and will be predicted wrong for other players (we get our own ammo in the playerstate)
	//rwwFIXME: if we have proper weapon switching when you run out of ammo will this actually be necessary?
	//i don't think it's all that costly, but still.
	int primAmmo = msg.ReadBits(ASYNC_PLAYER_INV_AMMO_BITS);
	int altAmmo = msg.ReadBits(ASYNC_PLAYER_INV_AMMO_BITS);
	if (entityNumber != gameLocal.localClientNum) {
		//since we have our own ammo in the playerstate, don't want to stomp it
		if (weapon.IsValid()) {
			ammo_t ammoType = weapon->GetAmmoType();
			if (ammoType > 0) {
				inventory.ammo[ammoType] = primAmmo;
			}
			ammoType = weapon->GetAltAmmoType();
			if (ammoType > 0) {
				inventory.ammo[ammoType] = altAmmo;
			}
		}
	}

	//need to sync buttonMask since we're using it for some state-based things
	buttonMask = msg.ReadBits(8);

	SetEyeHeight(msg.ReadFloat());

	//HUMANHEAD PCF rww 05/04/06 - do not sync AI_VEHICLE, it is now based purely on the clientside
	//enter/exit of vehicles, with the vehControlling stack bool determining if we should be in a
	//vehicle on the client or not.
	//AI_VEHICLE = !!msg.ReadBits(1);

	//rww - hand stuff
	//weaponHandState.ReadFromSnapshot(msg);
	hand.SetSpawnId(msg.ReadBits(32));
	handNext.SetSpawnId(msg.ReadBits(32));

	//HUMANHEAD PCF rww 05/04/06 - base this check on AI_VEHICLE and make sure the player is exited,
	//even if the vehicle is not in the snapshot at this point.
	if (!vehControlling && AI_VEHICLE) { //then exit on the client
		if (vehicleInterfaceLocal.ControllingVehicle()) {
			hhVehicle *veh = GetVehicleInterface()->GetVehicle();
			if (veh && veh->GetPilot() == this) {
				veh->EjectPilot();
			}
		}
		ExitVehicle(NULL); //be extra safe in case vehicle is no longer around
	}

	//jsh - vehicle stuff
	int vehSpawnId = msg.ReadBits( 32 );
	//HUMANHEAD PCF rww 05/04/06 - base this check ON AI_VEHICLE, in case snapshot where controlling and
	//where the vehicle is set do not exactly coincide.
	vehicleInterfaceLocal.SetVehicleSpawnId( vehSpawnId );
	if( !AI_VEHICLE ) {
		if (vehControlling) {
			hhVehicle *veh = vehicleInterfaceLocal.GetVehicle();
			if (veh && veh->IsType(hhVehicle::Type)) {
				//GetVehicleInterface()->TakeControl( vehicleInterfaceLocal.GetVehicle(), this );
				EnterVehicle( vehicleInterfaceLocal.GetVehicle() );
			}
		}
	}

	/*
	if( vehicleInterfaceLocal.SetHandSpawnId( msg.ReadBits( 32 ) ) ) {
		vehicleInterfaceLocal.GetHandEntity()->AttachHand( this, true );
	}
	*/
	vehicleInterfaceLocal.SetHandSpawnId( msg.ReadBits( 32 ) );
	//vehicleInterfaceLocal.GetWeaponHandState()->ReadFromSnapshot(msg);

	//rww - lighter sync validation
	bool newLighterOn = !!msg.ReadBits(1);
	if (newLighterOn != IsLighterOn()) {
		ToggleLighter();
	}

	//rww - tractor
	fl.isTractored = !!msg.ReadBits(1);

	spiritwalkSoundController.ReadFromSnapshot(msg);
	//deathwalkSoundController.ReadFromSnapshot(msg);
	wallwalkSoundController.ReadFromSnapshot(msg);

	//=========================================== start id code
	if ( weapon.SetSpawnId( weaponSpawnId ) ) {
		//HUMANHEAD rww - i am getting crashes here and the stack is all messed up,
		//claiming that SetOwner is off into null, when supposedly the entity is not.
		//rearranging this code so it's easier to see what's going on in a crash.
		hhWeapon *weapEnt = weapon.GetEntity();
		if ( weapEnt ) {
			// maintain ownership locally
			weapEnt->SetOwner( this );
		}
		currentWeapon = -1;
	}

	//HUMANHEAD rww - but we do want ammo count for the leechgun on other players for prediction
	//note - current weapon's ammo always sent now
	//ammo_t energyammo = hhWeaponFireController::GetAmmoType("ammo_energy");
	//inventory.ammo[energyammo] = msg.ReadBits(ASYNC_PLAYER_INV_AMMO_BITS);

	if ( oldHealth > 0 && health <= 0 ) {
		if ( stateHitch ) {
			// so we just hide and don't show a death skin
			UpdateDeathSkin( true );
		}
		// die
		AI_DEAD = true;
		SetAnimState( ANIMCHANNEL_LEGS, "Legs_Death", 4 );
		SetAnimState( ANIMCHANNEL_TORSO, "Torso_Death", 4 );
		SetWaitState( "" );
		animator.ClearAllJoints();

		//HUMANHEAD rww - don't want this
		/*
		if ( entityNumber == gameLocal.localClientNum ) {
			playerView.Fade( colorBlack, 12000 );
		}
		*/
		//HUMANHEAD END

		fl.clientEvents = true; //client event hackery for non-critical cosmetic cleanups
		PostEventMS(&EV_RespawnCleanup, 32);
		fl.clientEvents = false;
		StartRagdoll();
		physicsObj.SetMovementType( PM_DEAD );
		if ( !stateHitch ) {
			//HUMANHEAD PCF rww 09/15/06 - female mp sounds
			if (IsFemale()) {
				StartSound( "snd_death_female", SND_CHANNEL_VOICE, 0, false, NULL );
			}
			else {
				//HUMANHEAD END
			StartSound( "snd_death", SND_CHANNEL_VOICE, 0, false, NULL );
		}
		}
		if ( weapon.GetEntity() ) {
			weapon.GetEntity()->OwnerDied();
		}

		//HUMANHEAD rww
		GetPhysics()->SetContents(0);
		Hide();

		//so camera can operate on client.
		minRespawnTime = gameLocal.time + RAGDOLL_DEATH_TIME;
		maxRespawnTime = minRespawnTime + 10000;
		//HUMANHEAD END
	} else if ( oldHealth <= 0 && health > 0 ) {
		// respawn
		Init();
		StopRagdoll();
		SetPhysics( &physicsObj );
		physicsObj.EnableClip();
		SetCombatContents( true );
		//HUMANHEAD rww
		if (!spectating) {
			Show();
		}
		//HUMANHEAD END
	} else if ( health < oldHealth && health > 0 ) {
		if ( stateHitch ) {
			lastDmgTime = gameLocal.time;
		} else {
			// damage feedback
			const idDeclEntityDef *def = static_cast<const idDeclEntityDef *>( declManager->DeclByIndex( DECL_ENTITYDEF, lastDamageDef, false ) );
			if ( def ) {
				playerView.DamageImpulse( lastDamageDir * viewAxis.Transpose(), &def->dict );
				AI_PAIN = Pain( NULL, NULL, oldHealth - health, lastDamageDir, lastDamageLocation );
				lastDmgTime = gameLocal.time;
			} else {
				common->Warning( "NET: no damage def for damage feedback '%s'\n", lastDamageDef );
			}
		}
	}

	// If the player is alive, restore proper physics object
	if ( health > 0 && IsActiveAF() ) {
		StopRagdoll();
		SetPhysics( &physicsObj );
		physicsObj.EnableClip();
		SetCombatContents( true );
	}

	if ( idealWeapon != newIdealWeapon ) {
		if ( stateHitch ) {
			weaponCatchup = true;
		}
		idealWeapon = newIdealWeapon;
		UpdateHudWeapon();
	}

	if ( lastHitToggle != newHitToggle ) {
		SetLastHitTime( gameLocal.realClientTime );
	}
	//=========================================== end id code

	if ( msg.HasChanged() ) {
		UpdateVisuals();
	}
}

/*
================
hhPlayer::ServerReceiveEvent
================
*/
bool hhPlayer::ServerReceiveEvent( int event, int time, const idBitMsg &msg ) {
	if ( idEntity::ServerReceiveEvent( event, time, msg ) ) {
		return true;
	}

	// client->server events
	switch( event ) {
		case EVENT_IMPULSE: {
			int impulse = msg.ReadBits( 6 );
			PerformImpulse(impulse);
			if (vehicleInterfaceLocal.ControllingVehicle()) {
				hhVehicle *veh = vehicleInterfaceLocal.GetVehicle();
				if (veh) {
					veh->DoPlayerImpulse(impulse);
				}
			}
			return true;
		}
		default: {
			return false;
		}
	}
}

/*
================
hhPlayer::WritePlayerStateToSnapshot
================
*/
void hhPlayer::WritePlayerStateToSnapshot( idBitMsgDelta &msg ) const {
	idPlayer::WritePlayerStateToSnapshot(msg);

	//rww - extra playerView stuff
	playerView.WriteToSnapshot(msg);

	//rww - scope view
	msg.WriteBits(bScopeView, 1);

	//rww - zoom fov
	msg.WriteFloat(zoomFov.GetDuration());
	msg.WriteFloat(zoomFov.GetEndValue());
	msg.WriteFloat(zoomFov.GetStartTime());
	msg.WriteFloat(zoomFov.GetStartValue());

	//rww - view angle sensitivity
	msg.WriteFloat(GetViewAnglesSensitivity());
}

/*
================
hhPlayer::ReadPlayerStateFromSnapshot
================
*/
void hhPlayer::ReadPlayerStateFromSnapshot( const idBitMsgDelta &msg ) {
	idPlayer::ReadPlayerStateFromSnapshot(msg);

	//rww - extra playerView stuff
	playerView.ReadFromSnapshot(msg);

	//rww - scope and fov handling
	bool canOverrideView = true;
	if (weapon.IsValid() && weapon->IsType(hhWeaponZoomable::Type)) { //if we have a zoomed weapon, don't override with snapshot while the prediction fudge timer is on
		hhWeaponZoomable *weap = static_cast<hhWeaponZoomable *>(weapon.GetEntity());
		if (weap->clientZoomTime >= gameLocal.time) {
			canOverrideView = false;
		}
	}

	bool scopeView = !!msg.ReadBits(1);
	float zfDur = msg.ReadFloat();
	float zfEnd = msg.ReadFloat();
	float zfStT = msg.ReadFloat();
	float zfStV = msg.ReadFloat();

	renderSystem->SetShuttleView( InVehicle() );

	if (canOverrideView) { //if we are currently allowed to override with snapshot values, do so.
		bScopeView = scopeView;
		if (bScopeView != renderSystem->IsScopeView()) {
			renderSystem->SetScopeView(bScopeView);
		}
		zoomFov.SetDuration(zfDur);
		zoomFov.SetEndValue(zfEnd);
		zoomFov.SetStartTime(zfStT);
		zoomFov.SetStartValue(zfStV);
	}

	//rww - view angle sensitivity
	SetViewAnglesSensitivity(msg.ReadFloat());
}

/*
================
hhPlayer::ClientPredictionThink
================
*/
void hhPlayer::ClientPredictionThink( void ) {
	if (gameLocal.localClientNum != entityNumber && forcePredictionButtons) {
		//used by some weapons which rely on prediction-based projectiles, to ensure we don't miss a launch
		gameLocal.usercmds[ entityNumber ].buttons |= forcePredictionButtons;
		if (gameLocal.isNewFrame) {
			forcePredictionButtons = 0;
		}
	}

	idPlayer::ClientPredictionThink();

	if (InVehicle()) {
		UpdateHud( GetVehicleInterfaceLocal()->GetHUD() );
	}
	else {
		UpdateHud( hud );
	}
}

/*
================
hhPlayer::GetPhysicsToVisualTransform
================
*/
bool hhPlayer::GetPhysicsToVisualTransform( idVec3 &origin, idMat3 &axis ) {
	if ( af.IsActive() ) {
		af.GetPhysicsToVisualTransform( origin, axis );
		return true;
	}

	//rww - adopted id's smoothing code
	if ( gameLocal.isClient && !bindMaster && gameLocal.framenum >= smoothedFrame && ( entityNumber != gameLocal.localClientNum || selfSmooth ) ) {
		if (!smoothedOriginUpdated) {
			idVec3 renderOrigin = TransformToPlayerSpace(modelOffset);
			idVec3 originalOrigin = renderOrigin;

			//id's cheesy smooth code (changed to vec3 because there is no "down" in prey)
			idVec3 originDiff = renderOrigin - smoothedOrigin;
			if (smoothedFrame == 0) { //for teleporting
				originDiff = vec3_origin;
			}
			smoothedOrigin = renderOrigin;
			if ( originDiff.LengthSqr() < Square( 100.0f ) ) {
				// smoothen by pushing back to the previous position
				if ( selfSmooth ) {
					assert( entityNumber == gameLocal.localClientNum );
					renderOrigin -= net_clientSelfSmoothing.GetFloat() * originDiff;
				} else {
					renderOrigin -= gameLocal.clientSmoothing * originDiff;
				}

				//get rid of the smoothing on the "vertical" axis
				idVec3 a(renderOrigin.x*viewAxis[2].x, renderOrigin.y*viewAxis[2].y, renderOrigin.z*viewAxis[2].z);
				idVec3 b(originalOrigin.x*viewAxis[2].x, originalOrigin.y*viewAxis[2].y, originalOrigin.z*viewAxis[2].z);
				renderOrigin -= (a-b);
			}

			smoothedFrame = gameLocal.framenum;
			smoothedOriginUpdated = true;
		}

		axis = viewAxis;
		origin = ( smoothedOrigin - GetPhysics()->GetOrigin() ) * GetEyeAxis().Transpose();
		return true;
	}

	if (bClampYaw) { //rww - lock model angles
		idVec3 masterOrigin;
		idMat3 masterAxis;

		if (GetMasterPosition(masterOrigin, masterAxis)) {
			axis = masterAxis;
			origin = modelOffset;

			return true;
		}
	}

	axis = viewAxis;
	origin = modelOffset;

	return true;
}

bool hhPlayer::UpdateAnimationControllers( void ) {
	bool retValue = idPlayer::UpdateAnimationControllers();

	hhAnimator *theAnimator;
	if (head.IsValid()) {
		theAnimator = head->GetAnimator();
	}
	else {
		theAnimator = GetAnimator();
	}
	JawFlap(theAnimator);

	return retValue;
}

/*
===============
hhPlayer::Event_PlayWeaponAnim
===============
*/
void hhPlayer::Event_PlayWeaponAnim( const char* animName, int numTries ) {
	//AOB: I would like a better solution then constantly banging until weapon is valid.
	if( (!weapon.IsValid() || GetCurrentWeapon() != idealWeapon) && numTries > 0 ) {
		CancelEvents( &EV_PlayWeaponAnim );
		PostEventMS( &EV_PlayWeaponAnim, 50, animName, numTries - 1 ); 
		return;
	}

	CancelEvents( &EV_PlayWeaponAnim );
	if( weapon.IsValid() ) {
		weapon->ProcessEvent( &EV_PlayAnimWhenReady, animName );
	}
}

void hhPlayer::DialogStart(bool bDisallowPlayerDeath, bool bVoiceDucking, bool bLowerWeapon) {
	bDialogDamageMode = bDisallowPlayerDeath;
	bDialogWeaponMode = bLowerWeapon;
	gameLocal.DialogSoundMode(bVoiceDucking);
	if (bDialogWeaponMode) {	// Lock weapon
		preCinematicWeaponFlags = weaponFlags;
		preCinematicWeapon = GetIdealWeapon();
		LockWeapon(-1);
	}
}

void hhPlayer::DialogStop() {
	bDialogDamageMode = false;
	gameLocal.DialogSoundMode(false);
	if (bDialogWeaponMode) {
		weaponFlags = preCinematicWeaponFlags;
		SelectWeapon(preCinematicWeapon, true);
		bDialogWeaponMode = false;
	}
}

/*
===============
hhPlayer::Event_DialogStart
	HUMANHEAD pdm
===============
*/
void hhPlayer::Event_DialogStart( int bDisallowPlayerDeath, int bVoiceDucking, int bLowerWeapon ) {
	DialogStart(bDisallowPlayerDeath != 0, bVoiceDucking != 0, bLowerWeapon != 0);
}

/*
===============
hhPlayer::Event_DialogStop
	HUMANHEAD pdm
===============
*/
void hhPlayer::Event_DialogStop() {
	DialogStop();
}

/*
===============
hhPlayer::Event_LotaTunnelMode
	HUMANHEAD pdm
===============
*/
void hhPlayer::Event_LotaTunnelMode(bool on) {
	bLotaTunnelMode = on;
}

/*
===============
hhPlayer::Event_Cinematic
	HUMANHEAD pdm
===============
*/
void hhPlayer::Event_Cinematic( int on, int lockView ) {
	bool cinematic = (on != 0);
	InCinematic( cinematic );
	playerView.SetLetterBox(cinematic);
	if (cinematic) {
		if ( IsSpiritOrDeathwalking() ) {
			StopSpiritWalk();
		}
		if ( IsPossessed() ) {
			Unpossess();
		}

		// Lock weapon
		preCinematicWeaponFlags = weaponFlags;
		preCinematicWeapon = GetCurrentWeapon();
		LockWeapon(-1);

		// disable damage
		fl.takedamage = false;
		this->lockView = (lockView != 0);
	}
	else {
		fl.takedamage = true;
		this->lockView = false;

		//UnlockWeapon(preCinematicWeapon);
		weaponFlags = preCinematicWeaponFlags;
		//SetCurrentWeapon(preCinematicWeapon);
		SelectWeapon(preCinematicWeapon, true);
	}
}

//=============================================================================
//
// hhPlayer::Event_PrepareToResurrect
//
// Flashes the screen / fades the FOV
//=============================================================================

void hhPlayer::Event_PrepareToResurrect() {	
	deathWalkFlash = 0;
	possessionFOV = 90.0f;
	PostEventSec( &EV_ResurrectScreenFade, 0 );
}

//=============================================================================
//
// hhPlayer::Event_ResurrectScreenFade
//
// The actual code to incrementally flash the screen
//=============================================================================

void hhPlayer::Event_ResurrectScreenFade() {
	deathWalkFlash += spawnArgs.GetFloat( "resurrectFlashChange", "0.04" );
	if ( deathWalkFlash >= 1.0f ) {
		deathWalkFlash = 1.0f;
		PostEventSec( &EV_Resurrect, 0.0f ); // Actually send player back to the physical realm
	} else {
		PostEventSec( &EV_ResurrectScreenFade, 0.02f );
	}

	possessionFOV += spawnArgs.GetFloat( "resurrectFOVChange", "1.0" );
	playerView.SetViewOverlayColor( idVec4( 1.0f, 1.0f, 1.0f, deathWalkFlash ) );
}

//=============================================================================
//
// hhPlayer::Event_Resurrect
//
//=============================================================================
void hhPlayer::Event_Resurrect() {
	Resurrect();
}

//=============================================================================
//
// hhPlayer::Event_Event_ShouldRemainAlignedToAxial
//
//=============================================================================
void hhPlayer::Event_ShouldRemainAlignedToAxial( bool remainAligned ) {
	ShouldRemainAlignedToAxial( remainAligned );
}

//=============================================================================
//
// hhPlayer::Event_OrientToGravity
//
//=============================================================================
void hhPlayer::Event_OrientToGravity( bool orient ) {
	OrientToGravity( orient );
}

//=============================================================================
//
// hhPlayer::Event_ResetGravity
//	HUMANHEAD: pdm: Posted when entity is leaving a gravity zone
//=============================================================================
void hhPlayer::Event_ResetGravity() {
	if( IsWallWalking() ) {
		return;	// Don't reset if wallwalking
	}

	if (spectating) { //HUMANHEAD rww - don't reset if spectating
		return;
	}

	idPlayer::Event_ResetGravity();

	OrientToGravity( true );	// let it reset orientation
}

//=============================================================================
//
// hhPlayer::Event_SetOverlayMaterial
//
//=============================================================================
void hhPlayer::Event_SetOverlayMaterial( const char *mtrName, const int requiresScratch ) {
	if ( mtrName && mtrName[0] ) {
		playerView.SetViewOverlayMaterial( declManager->FindMaterial(mtrName), requiresScratch );
	} else {
		playerView.SetViewOverlayMaterial( NULL );
	}
}

//=============================================================================
//
// hhPlayer::Event_SetOverlayTime
//
//=============================================================================
void hhPlayer::Event_SetOverlayTime( const float newTime, const int requiresScratch ) {
	playerView.SetViewOverlayTime( newTime, requiresScratch );
}

//=============================================================================
//
// hhPlayer::Event_SetOverlayColor
//
//=============================================================================
void hhPlayer::Event_SetOverlayColor( const float r, const float g, const float b, const float a ) {
	idVec4 color;

	color.x = r;
	color.y = g;
	color.z = b;
	color.w = a;

	playerView.SetViewOverlayColor( color );
}

//=============================================================================
//
// hhPlayer::Event_DDAHeartBeat
//
//=============================================================================

void hhPlayer::Event_DDAHeartBeat() {
	gameLocal.GetDDA()->DDA_Heartbeat( this );
	PostEventMS( &EV_DDAHeartbeat, ddaHeartbeatMS );
}

//================
//hhPlayer::Save
//================
void hhPlayer::Save( idSaveGame *savefile ) const {
	// Public vars
	savefile->Write(weaponInfo, sizeof(weaponInfo_t)*15);
	savefile->Write(altWeaponInfo, sizeof(weaponInfo_t)*15);
	savefile->WriteFloat( lighterTemperature );
	savefile->WriteRenderLight( lighter );
	//HUMANHEAD PCF mdl 05/04/06 - Don't save light handles
    //savefile->WriteInt( lighterHandle );
	spiritProxy.Save( savefile );
	savefile->WriteInt( lastWeaponSpirit );
	talon.Save( savefile );
	savefile->WriteInt( nextTalonAttackCommentTime );
	savefile->WriteBool( bTalonAttackComment );
	savefile->WriteBool( bSpiritWalk );
	savefile->WriteBool( bDeathWalk );
	savefile->WriteBool( bReallyDead );
	guiWantsControls.Save( savefile );
	savefile->WriteFloat( deathWalkFlash );
	savefile->WriteInt( deathWalkTime );
	savefile->WriteInt( deathWalkPower );
	savefile->WriteBool( bInDeathwalkTransition );
	savefile->WriteBool( bInCinematic );
	savefile->WriteBool( bPlayingLowHealthSound );
	savefile->WriteBool( bPossessed );
	savefile->WriteFloat( possessionTimer );
	savefile->WriteFloat( possessionFOV );
	savefile->WriteInt( preCinematicWeapon );
	savefile->WriteInt( preCinematicWeaponFlags );
	savefile->WriteInt( lastDamagedTime );
	savefile->WriteStaticObject( weaponHandState );
	hand.Save( savefile );
	handNext.Save( savefile );
	possessedTommy.Save( savefile );

	savefile->WriteStaticObject( vehicleInterfaceLocal );
	savefile->WriteObject( vehicleInterfaceLocal.GetVehicle() );

	deathLookAtEntity.Save( savefile );
	savefile->WriteString( deathLookAtBone );
	savefile->WriteString( deathCameraBone );
	savefile->WriteStaticObject( spiritwalkSoundController );
	savefile->WriteStaticObject( deathwalkSoundController );
	savefile->WriteStaticObject( wallwalkSoundController );
	savefile->WriteBool( bShowProgressBar );
	savefile->WriteFloat( progressBarValue );

	savefile->WriteFloat( progressBarGuiValue.GetStartTime() );	// idInterpolate<float>
	savefile->WriteFloat( progressBarGuiValue.GetDuration() );
	savefile->WriteFloat( progressBarGuiValue.GetStartValue() );
	savefile->WriteFloat( progressBarGuiValue.GetEndValue() );

	savefile->WriteInt( progressBarState );
	savefile->WriteBool( bClampYaw );
	savefile->WriteFloat( maxRelativeYaw );
	savefile->WriteFloat( maxRelativePitch );
	savefile->WriteFloat( bob );
	savefile->WriteInt( lastAppliedBobCycle );
	savefile->WriteInt( prevStepUpTime );
	savefile->WriteVec3( prevStepUpOrigin );
	savefile->WriteFloat( crashlandSpeed_fatal );
	savefile->WriteFloat( crashlandSpeed_soft );
	savefile->WriteFloat( crashlandSpeed_jump );
	// Protected vars
	savefile->WriteUserInterface( guiOverlay, false );
	thirdPersonCameraClipBounds.Save( savefile );
	savefile->WriteFloat( viewAnglesSensitivity );
	savefile->WriteInt( lastResurrectTime );
	savefile->WriteInt( spiritDrainHeartbeatMS );
	savefile->WriteInt( ddaHeartbeatMS );

	savefile->WriteInt( spiritWalkToggleTime );
	savefile->WriteBool( bDeathWalkStage2 );
	savefile->WriteBool( bFrozen );
	savefile->WriteAngles( untransformedViewAngles );
	savefile->WriteMat3( untransformedViewAxis );
	savefile->WriteInt( nextSpiritTime );

	savefile->WriteFloat( cinematicFOV.GetStartTime() );
	savefile->WriteFloat( cinematicFOV.GetAcceleration() );
	savefile->WriteFloat( cinematicFOV.GetDeceleration() );
	savefile->WriteFloat( cinematicFOV.GetDuration() );
	savefile->WriteFloat( cinematicFOV.GetStartValue() );
	savefile->WriteFloat( cinematicFOV.GetEndValue() );
	savefile->WriteBool( bAllowSpirit );
	savefile->WriteInt( airAttackerTime );
	savefile->WriteBool( bScopeView );
	savefile->WriteInt( ddaNumEnemies );
	savefile->WriteFloat( ddaProbabilityAccum );
	savefile->WriteInt( weaponFlags );
	savefile->WriteBool( lockView );

	savefile->WriteBool( bCollidingWithPortal );
	savefile->WriteBool( bLotaTunnelMode );
	savefile->WriteInt( forcePredictionButtons );

	for (int ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		lastAttackers[ix].attacker.Save( savefile );
		savefile->WriteInt( lastAttackers[ix].time );
		savefile->WriteBool( lastAttackers[ix].displayed );
	}

	if ( InVehicle() ) {
		savefile->WriteMat3( vehicleInterfaceLocal.GetVehicle()->GetPhysics()->GetAxis() );
		savefile->WriteVec3( vehicleInterfaceLocal.GetVehicle()->GetAxis()[0] );
	}

	//HUMANHEAD PCF mdl 04/28/06 - Moved camera interpolater down here to fix jump off wallwalk view angle problem
	cameraInterpolator.Save( savefile );
	//HUMANHEAD PCF mdl 05/04/06 - Save whether the light handle is active
	savefile->WriteBool( IsLighterOn() );
}

//================
//hhPlayer::Restore
//================
void hhPlayer::Restore( idRestoreGame *savefile ) {
	// Public vars
	savefile->Read(weaponInfo, sizeof(weaponInfo_t)*15);
	savefile->Read(altWeaponInfo, sizeof(weaponInfo_t)*15);
	savefile->ReadFloat( lighterTemperature );
	savefile->ReadRenderLight( lighter );
	//HUMANHEAD PCF mdl 05/04/06 - Don't save light handles
	//savefile->ReadInt( lighterHandle );
	spiritProxy.Restore( savefile );
	savefile->ReadInt( lastWeaponSpirit );
	talon.Restore( savefile );
	savefile->ReadInt( nextTalonAttackCommentTime );
	savefile->ReadBool( bTalonAttackComment );
	savefile->ReadBool( bSpiritWalk );
	savefile->ReadBool( bDeathWalk );
	savefile->ReadBool( bReallyDead );
	guiWantsControls.Restore( savefile );
	savefile->ReadFloat( deathWalkFlash );
	savefile->ReadInt( deathWalkTime );
	savefile->ReadInt( deathWalkPower );
	savefile->ReadBool( bInDeathwalkTransition );
	savefile->ReadBool( bInCinematic );
	savefile->ReadBool( bPlayingLowHealthSound );
	savefile->ReadBool( bPossessed );
	savefile->ReadFloat( possessionTimer );
	savefile->ReadFloat( possessionFOV );
	savefile->ReadInt( preCinematicWeapon );
	savefile->ReadInt( preCinematicWeaponFlags );
	savefile->ReadInt( lastDamagedTime );
	savefile->ReadStaticObject( weaponHandState );
	hand.Restore( savefile );
	handNext.Restore( savefile );
	possessedTommy.Restore( savefile );

	savefile->ReadStaticObject( vehicleInterfaceLocal );
	SetVehicleInterface( &vehicleInterfaceLocal );

	hhVehicle *vehicle;
	savefile->ReadObject( reinterpret_cast<idClass *&> ( vehicle ) );
	if( vehicle ) {
		vehicle->RestorePilot( &vehicleInterfaceLocal );
	}

	deathLookAtEntity.Restore( savefile );
	savefile->ReadString( deathLookAtBone );
	savefile->ReadString( deathCameraBone );
	savefile->ReadStaticObject( spiritwalkSoundController );
	savefile->ReadStaticObject( deathwalkSoundController );
	savefile->ReadStaticObject( wallwalkSoundController );
	savefile->ReadBool( bShowProgressBar );
	savefile->ReadFloat( progressBarValue );

	float set;
	savefile->ReadFloat( set );			// idInterpolate<float>
	progressBarGuiValue.SetStartTime( set );
	savefile->ReadFloat( set );
	progressBarGuiValue.SetDuration( set );
	savefile->ReadFloat( set );
	progressBarGuiValue.SetStartValue(set);
	savefile->ReadFloat( set );
	progressBarGuiValue.SetEndValue( set );

	savefile->ReadInt( progressBarState );
	savefile->ReadBool( bClampYaw );
	savefile->ReadFloat( maxRelativeYaw );
	savefile->ReadFloat( maxRelativePitch );
	savefile->ReadFloat( bob );
	savefile->ReadInt( lastAppliedBobCycle );
	savefile->ReadInt( prevStepUpTime );
	savefile->ReadVec3( prevStepUpOrigin );
	savefile->ReadFloat( crashlandSpeed_fatal );
	savefile->ReadFloat( crashlandSpeed_soft );
	savefile->ReadFloat( crashlandSpeed_jump );
	// Protected vars
	savefile->ReadUserInterface( guiOverlay );

	thirdPersonCameraClipBounds.Restore( savefile );
	savefile->ReadFloat( viewAnglesSensitivity );
	savefile->ReadInt( lastResurrectTime );
	savefile->ReadInt( spiritDrainHeartbeatMS );
	savefile->ReadInt( ddaHeartbeatMS );

	savefile->ReadInt( spiritWalkToggleTime );
	savefile->ReadBool( bDeathWalkStage2 );
	savefile->ReadBool( bFrozen );
	savefile->ReadAngles( untransformedViewAngles );
	savefile->ReadMat3( untransformedViewAxis );
	savefile->ReadInt( nextSpiritTime );

	float startTime, accelTime, decelTime, duration, startPos, endPos;

	savefile->ReadFloat( startTime );
	savefile->ReadFloat( accelTime );
	savefile->ReadFloat( decelTime );
	savefile->ReadFloat( duration );
	savefile->ReadFloat( startPos );
	savefile->ReadFloat( endPos );
	cinematicFOV.Init( startTime, accelTime, decelTime, duration, startPos, endPos );
	savefile->ReadBool( bAllowSpirit );
	savefile->ReadInt( airAttackerTime );
	savefile->ReadBool( bScopeView );
	savefile->ReadInt( ddaNumEnemies );
	savefile->ReadFloat( ddaProbabilityAccum );
	savefile->ReadInt( weaponFlags );
	savefile->ReadBool( lockView );

	savefile->ReadBool( bCollidingWithPortal );
	savefile->ReadBool( bLotaTunnelMode );
	savefile->ReadInt( forcePredictionButtons );

	for (int ix=0; ix<MAX_TRACKED_ATTACKERS; ix++) {
		lastAttackers[ix].attacker.Restore( savefile );
		savefile->ReadInt( lastAttackers[ix].time );
		savefile->ReadBool( lastAttackers[ix].displayed );
	}

	// We don't want to preserve these
	memset( &oldCmdAngles, 0, sizeof( oldCmdAngles ) );

	kickSpring = spawnArgs.GetFloat( "kickSpring" );	//HUMANHEAD bjk
	kickDamping = spawnArgs.GetFloat( "kickDamping" );	//HUMANHEAD bjk

	if( InVehicle() ) {
		hhVehicle *vehicle = vehicleInterfaceLocal.GetVehicle();
		HH_ASSERT( vehicle );

		idMat3 axis;
		idVec3 axis0;

		// This prevents a crashbug if the vehicle's physics doesn't exist yet.
		savefile->ReadMat3( axis ); // vehicle->GetPhysics()->GetAxis()
		savefile->ReadVec3( axis0 ); // vehicle->GetAxis()[0]

		// Keep orientation correct in vehicles
		RestoreOrientation( GetOrigin(), axis, axis0, axis0.ToAngles() );

		//HUMANHEAD PCF mdl 05/02/06 - Added this to re-enable shuttle view
		if (renderSystem) {
			// Set shuttle view
			renderSystem->SetShuttleView( true );
		}
	} else {
		// Keep orientation correct for walkwalk and gravity rooms
		RestoreOrientation( GetOrigin(), physicsObj.GetAxis(), viewAngles.ToMat3()[0], untransformedViewAngles );
	}

	//HUMANHEAD PCF mdl 04/28/06 - Moved camera interpolater down here to fix jump off wallwalk view angle problem
	cameraInterpolator.Restore( savefile );

	//HUMANHEAD PCF mdl 05/04/06 - Restore lighter
	bool bLighter;
	savefile->ReadBool( bLighter );
	if ( bLighter ) {
		lighterHandle = gameRenderWorld->AddLightDef( &lighter );
	}
}

int hhPlayer::GetSpiritPower() {
	ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName("ammo_spiritpower");
	return inventory.ammo[ammo_spiritpower];
}

void hhPlayer::SetSpiritPower(int amount) {
	ammo_t ammo_spiritpower = idWeapon::GetAmmoNumForName("ammo_spiritpower");
	inventory.ammo[ammo_spiritpower] = amount;
	if (inventory.ammo[ammo_spiritpower] > inventory.maxSpirit) {
		inventory.ammo[ammo_spiritpower] = inventory.maxSpirit;
	}
}

void hhPlayer::Event_StartHUDTranslation() {
	vehicleInterfaceLocal.StartHUDTranslation();
}

void hhPlayer::Freeze(float unfreezeDelay) {
	bFrozen = true;
	StopFiring();
	if ( weapon.IsValid() ) {
		weapon->PutAway();
	}
	if ( unfreezeDelay > 0.0f ) {
		PostEventSec( &EV_Unfreeze, unfreezeDelay );
	}
}

void hhPlayer::Unfreeze(void) {
	bFrozen = false;
	if ( weapon.IsValid() ) {
		weapon->PostEventMS( &EV_Show, 1000 );
		weapon->PostEventMS( &EV_Weapon_WeaponRising, 1000 );
	}
}

void hhPlayer::Event_Unfreeze() {
	Unfreeze();
	if ( bindMaster && bindMaster->RespondsTo( EV_BindUnfroze ) ) {
		GetBindMaster()->PostEventMS( &EV_BindUnfroze, 0, this );
	}
}

void hhPlayer::Event_GetSpiritPower() { //rww
	idThread::ReturnFloat((float)GetSpiritPower());
}

void hhPlayer::Event_SetSpiritPower(const float s) { //rww
	SetSpiritPower((int)s);
}

void hhPlayer::Event_OnGround() { // bg
	idThread::ReturnFloat( physicsObj.HasGroundContacts() );
}

void hhPlayer::SetupWeaponFlags( void ) {
	const char *mapName = gameLocal.serverInfo.GetString( "si_map" );
	const idDecl *mapDecl = declManager->FindType(DECL_MAPDEF, mapName, false );
	if ( !mapDecl ) {
		weaponFlags = -1; // No map decls?  Allow all weapons
		return;
	}
	const idDeclEntityDef *mapInfo = static_cast<const idDeclEntityDef *>(mapDecl);

	const char *weaponList = mapInfo->dict.GetString( "disableWeapons" );
	weaponFlags = 0;
	if ( weaponList && weaponList[0] ) {
		if ( !idStr::Icmp( weaponList, "all" ) ) {
			// No weapons are enabled, so just return
			return;
		}

		if ( idStr::FindText( weaponList, "wrench", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_WRENCH;
		}
		if ( idStr::FindText( weaponList, "rifle", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_RIFLE;
		}
		if ( idStr::FindText( weaponList, "crawler", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_CRAWLER;
		}
		if ( idStr::FindText( weaponList, "autocannon", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_AUTOCANNON;
		}
		if ( idStr::FindText( weaponList, "hiderweapon", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_HIDERWEAPON;
		}
		if ( idStr::FindText( weaponList, "rocketlauncher", false ) == -1 ) {
			weaponFlags |= HH_WEAPON_ROCKETLAUNCHER;
		}
		if ( idStr::FindText( weaponList, "soulstripper", false ) == -1 ){ 
			weaponFlags |= HH_WEAPON_SOULSTRIPPER;
		}
	}

	if ( weaponFlags == 0 ) {
		// Allow all weapons by default
		weaponFlags = -1;
	}
}

void hhPlayer::LockWeapon( int weaponNum ) {
	// Special case, -1 locks all weapons AND the lighter
	if ( weaponNum == -1 ) {
		if (IsLighterOn()) {
			LighterOff();
		}
		if (weapon.IsValid()) {
			weapon->PutAway();
		}
		weaponFlags = 0;
		idealWeapon = 0;
		currentWeapon = 0;
		return;
	}

	if ( weaponNum <= 0 || weaponNum >= MAX_WEAPONS ) {
		gameLocal.Error( "Attempted to unlock unknown weapon '%d'", weaponNum );
	}

	int flag = ( 1 << ( weaponNum - 1 ) ); 
	if ( weaponFlags & flag ) { // Only lock if not already locked
		weaponFlags &= ~flag;
		if ( idealWeapon == weaponNum ) {
			if (weapon.IsValid()) {
				weapon->PutAway();
			}
			NextWeapon();
		}
	}
}

void hhPlayer::UnlockWeapon( int weaponNum ) {
	// Special case, -1 unlocks all weapons
	if ( weaponNum == -1 ) {
		weaponFlags = -1;
		if ( idealWeapon == 0 )  {
			idealWeapon = 1; // Default to the wrench
		}
		return;
	}

	if ( weaponNum <= 0 || weaponNum >= MAX_WEAPONS ) {
		gameLocal.Error( "Attempted to unlock unknown weapon '%d'", weaponNum );
	}

	int flag = ( 1 << ( weaponNum - 1 ) ); 
	if ( weaponFlags & flag ) {
		// Already unlocked
		return;
	}

	weaponFlags |= flag;
	idealWeapon = weaponNum;
}

bool hhPlayer::IsLocked(int weaponNum) {
	//HUMANHEAD PCF mdl 05/05/06 - Changed to < 1 to catch weaponNum = -1
	if (weaponNum < 1) {
		return true; // CJR: if the player has no weapons, then consider all weapons locked
	}
	return !(weaponFlags & (1 << (weaponNum-1)));
}

void hhPlayer::Event_LockWeapon( int weaponNum ) {
	LockWeapon( weaponNum );
}

void hhPlayer::Event_UnlockWeapon( int weaponNum ) {
	UnlockWeapon( weaponNum );
}

//HUMANHEAD rdr
void hhPlayer::Event_SetPrivateCameraView( idEntity *camView, int noHide ) {
	if ( camView && camView->IsType( idCamera::Type ) ) {
		idPlayer::SetPrivateCameraView( static_cast<idCamera*>( camView ), noHide != 0 );
	}
	else {
		idPlayer::SetPrivateCameraView( NULL );
	}
}

//HUMANHEAD rdr
void hhPlayer::Event_SetCinematicFOV( float fieldOfView, float accelTime, float decelTime, float duration ) {
	if ( duration > 0.f ) {
		cinematicFOV.Init( gameLocal.time, SEC2MS( accelTime ), SEC2MS( decelTime ), SEC2MS( duration ), cinematicFOV.GetCurrentValue( gameLocal.GetTime() ), fieldOfView );
	} else {
		cinematicFOV.Init( gameLocal.time, 0.f, 0.f, 0.f, cinematicFOV.GetEndValue(), fieldOfView );
	}
}

//HUMANHEAD rww
void hhPlayer::Event_StopSpiritWalk() {
	StopSpiritWalk();
}

void hhPlayer::Event_DamagePlayer(idEntity *inflictor, idEntity *attacker, const idVec3 &dir, char *damageDefName, float damageScale, int location) {
	Damage(inflictor, attacker, dir, damageDefName, damageScale, location);
}
//HUMANHEAD END

void hhPlayer::Event_GetSpiritProxy() {
	if ( spiritProxy.IsValid() ) {
		idThread::ReturnEntity( spiritProxy.GetEntity() );
	} else {
		idThread::ReturnEntity( NULL );
	}
}

void hhPlayer::Event_IsSpiritWalking() {
	idThread::ReturnInt( IsSpiritWalking() ? 1 : 0 );
}

void hhPlayer::Event_IsDeathWalking() {
	idThread::ReturnInt( IsDeathWalking() ? 1 : 0 );
}

void hhPlayer::Event_AllowLighter( bool allow ) {
	inventory.requirements.bCanUseLighter = allow;
	if ( !allow && IsLighterOn() ) {
		LighterOff();
	}
}

//=============================================================================
//
// hhPlayer::Event_GetDDAValue
//
// Returns the current DDA value from zero to one
//=============================================================================

void hhPlayer::Event_GetDDAValue() {
	idThread::ReturnFloat( gameLocal.GetDDAValue() );
}

//HUMANHEAD rww
hhArtificialPlayer::hhArtificialPlayer(void) {
	memset(&lastAICmd, 0, sizeof(lastAICmd));
	testCrouchActive = false;
	testCrouchTime = 0;
}

void hhArtificialPlayer::Spawn( void ) {
	idDict apUI;
	gameLocal.GetAPUserInfo(apUI, entityNumber);
	gameLocal.SetUserInfo(entityNumber, apUI, gameLocal.isClient, false);

	SetPlayerModel(false); //force an update on the player model
}

void hhArtificialPlayer::Think( void ) {
	PROFILE_START("hhArtificialPlayer::Think", PROFMASK_NORMAL);
	bool iFeelHoppy = false;
	usercmd_t *nextCmd = &gameLocal.usercmds[ entityNumber ];
	idAngles idealAngles = GetViewAngles();

	nextCmd->gameFrame = gameLocal.framenum;
	nextCmd->gameTime = gameLocal.time;

	nextCmd->forwardmove = idMath::ClampChar(127);

	//this is not meant to resemble proper ai logic, it's just for testing.
	idEntity *closestEnt = NULL;
	float closestDist = idMath::INFINITY;	

	int numSourceAreas, sourceAreas[ idEntity::MAX_PVS_AREAS ];
	numSourceAreas = gameRenderWorld->BoundsInAreas( GetPlayerPhysics()->GetAbsBounds(), sourceAreas, idEntity::MAX_PVS_AREAS );
	pvsHandle_t pvsHandle = gameLocal.pvs.SetupCurrentPVS( sourceAreas, numSourceAreas, PVS_NORMAL );

	for(int i=0;i<gameLocal.numClients;i++) {
		idEntity *ent = gameLocal.entities[i];		
		if(ent) {
			HH_ASSERT(ent->IsType(hhPlayer::Type));
			hhPlayer *plEnt = static_cast<hhPlayer *>(ent);

			float l = (ent->GetOrigin()-GetOrigin()).Length();
			if(l < 4096.0f && (l < closestDist || !closestEnt) && ent->PhysicsTeamInPVS(pvsHandle)) {
				trace_t tr;

				gameLocal.clip.TracePoint(tr, GetOrigin(), ent->GetOrigin(), GetPhysics()->GetClipMask(), this);
				if (tr.c.entityNum == ent->entityNumber) { //if we hit the thing then it's visible.
					if (ent->health > 0) {
						if (gameLocal.gameType != GAME_TDM || plEnt->team != team) {
							closestDist = l;
							closestEnt  = ent;
						}
					}
				}
			}
		}
	}

	gameLocal.pvs.FreeCurrentPVS( pvsHandle );

	if (closestEnt) {
		idealAngles = (closestEnt->GetOrigin()-GetOrigin()).ToAngles();
	}
	else { //if no one to run mindlessly at, do some stuff.
		const float testDist = 64.0f;
		idVec3 fwd = GetOrigin()+(idealAngles.ToForward()*testDist);

		trace_t tr;
		gameLocal.clip.TraceBounds(tr, GetOrigin(), fwd, GetPhysics()->GetBounds(), GetPhysics()->GetClipMask(), this);
		if (tr.fraction != 1.0f) { //if we hit something set the yaw to a new random angle.
			iFeelHoppy = true;

			idealAngles.yaw = rand()%360;
		}
	}

	if ((closestEnt || health <= 0) && rand()%2 == 1) {
		nextCmd->buttons |= BUTTON_ATTACK;
	}
	else {
		nextCmd->buttons &= ~BUTTON_ATTACK;
	}

	if (testCrouchTime < gameLocal.time) {
		testCrouchTime = gameLocal.time + rand()%4000;
		testCrouchActive = !testCrouchActive;
	}

	if (iFeelHoppy) {
		nextCmd->upmove = idMath::ClampChar(127);
	}
	else {
		if (testCrouchActive) {
			nextCmd->upmove = idMath::ClampChar(-127);
		}
		else {
			nextCmd->upmove = 0;
		}
	}

	idealAngles.pitch = idMath::AngleNormalize180(idealAngles.pitch);
	idealAngles.yaw = idMath::AngleNormalize180(idealAngles.yaw);
	idealAngles.roll = idMath::AngleNormalize180(idealAngles.roll);
	SetUntransformedViewAngles(idAngles(0.0f, 0.0f, 0.0f));
	UpdateDeltaViewAngles(idealAngles);
	UpdateOrientation(idealAngles);
	PROFILE_STOP("hhArtificialPlayer::Think", PROFMASK_NORMAL);
	hhPlayer::Think();
}

void hhArtificialPlayer::ClientPredictionThink( void ) {
	gameLocal.usercmds[entityNumber] = lastAICmd; //copy over the last manually snapshotted usercmd first
	hhPlayer::ClientPredictionThink();
}

void hhArtificialPlayer::WriteToSnapshot( idBitMsgDelta &msg ) const {
	//instead of sync'ing, just mirror what the server has in ::Spawn
	/*
	msg.WriteDict(*gameLocal.GetUserInfo(entityNumber));	//ap's don't broadcast their info to the server, so the server otherwise
															//will never broadcast it out to other clients
	*/

	hhPlayer::WriteToSnapshot(msg);

	usercmd_t &cmd = gameLocal.usercmds[entityNumber];
	msg.WriteLong( cmd.gameTime );
	msg.WriteByte( cmd.buttons );
    msg.WriteShort( cmd.mx );
	msg.WriteShort( cmd.my );
	msg.WriteChar( cmd.forwardmove );
	msg.WriteChar( cmd.rightmove );
	msg.WriteChar( cmd.upmove );
	msg.WriteShort( cmd.angles[0] );
	msg.WriteShort( cmd.angles[1] );
	msg.WriteShort( cmd.angles[2] );

	msg.WriteBits(spectating, 1);
}

void hhArtificialPlayer::ReadFromSnapshot( const idBitMsgDelta &msg ) {
	/*
	((idBitMsgDelta)msg).ReadDict(*((idDict *)gameLocal.GetUserInfo(entityNumber)));
	if (!clientReceivedUI) {
		UserInfoChanged( false );
		clientReceivedUI = true;
	}
	*/

	hhPlayer::ReadFromSnapshot(msg);

	usercmd_t &cmd = lastAICmd;
	cmd.gameTime = msg.ReadLong();
    cmd.buttons = msg.ReadByte();
    cmd.mx = msg.ReadShort();
	cmd.my = msg.ReadShort();
	cmd.forwardmove = msg.ReadChar();
	cmd.rightmove = msg.ReadChar();
	cmd.upmove = msg.ReadChar();
	cmd.angles[0] = msg.ReadShort();
	cmd.angles[1] = msg.ReadShort();
	cmd.angles[2] = msg.ReadShort();

	bool spec = !!msg.ReadBits(1);	//doesn't go through right for ap's or something based on events sometimes, hack fix
	if (spec != spectating) {
		Spectate(spec);
	}
}
//HUMANHEAD END

void hhPlayer::DisableSpiritWalk(int timeout) {
	nextSpiritTime = gameLocal.time + SEC2MS(timeout);
	StopSpiritWalk();
}

//=============================================================================
//
// hhPlayer::Event_UpdateDDA
//
// CJR:  Update the probability the player will die this tick, and 
// adjust the difficulty accordingly
//=============================================================================

void hhPlayer::Event_UpdateDDA() {
	idEntity	*ent;
	int			updateFlags;

	// Find the number of alive, non-dormant creatures attacking the player
	ddaNumEnemies = 0;
	ddaProbabilityAccum = 1.0f;
	updateFlags = 0;

	for( ent = gameLocal.activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
		if ( ent->fl.isDormant || !ent->IsType( hhMonsterAI::Type ) || ent->fl.hidden || ent->health <= 0 ) {
			continue;
		}

		hhMonsterAI *monster = static_cast<hhMonsterAI *>(ent);
		if ( monster->GetEnemy() != this ) {
			continue;
		}

		// PVS Check:  only include creatures that the player can attack or be attacked by
		if ( !gameLocal.InPlayerPVS( ent ) ) {
			continue;
		}

		// Accumulate the survival rate against each enemy
		int index = monster->spawnArgs.GetInt( "ddaIndex", "0" );

		if ( index == -1 ) { // Skip certain monsters, such as the vacuum or the crawlers
			continue;
		}
			
		float prob = gameLocal.GetDDA()->DDA_GetProbability( index, GetHealth() );

		ddaProbabilityAccum *= prob;

		// Recompute the actual difficulty based upon the creatures in view
		updateFlags |= ( 1 << index );

		ddaNumEnemies++;
	}

	gameLocal.GetDDA()->RecalculateDifficulty( updateFlags );

	PostEventSec( &EV_UpdateDDA, spawnArgs.GetFloat( "updateDDARate", "0.25" ) );

	if ( g_printDDA.GetBool() ) {
		if ( ddaNumEnemies > 0 ){
			common->Printf("Probability [%.2f]\n", ddaProbabilityAccum );
		}
	}
}

void hhPlayer::Event_DisableSpirit(void) {
	// HUMANHEAD PCF pdm 05-17-06: Removed assert, as scripters were potentially calling during deathwalk
	// HUMANHEAD PCF pdm 05-17-06: Only exit spirit realm if spiritwalking, not deathwalking

	if ( IsSpiritWalking() ) {
		StopSpiritWalk();
	}

	bAllowSpirit = false;
}

void hhPlayer::Event_EnableSpirit(void) {
	// HUMANHEAD PCF pdm 05-17-06: Removed assert

	bAllowSpirit = true;
}

//HUMANHEAD bjk
void hhPlayer::ProjectOverlay( const idVec3 &origin, const idVec3 &dir, float size, const char *material ) {
	// no need for these in sp
	if( gameLocal.isMultiplayer ) {
		idActor::ProjectOverlay( origin, dir, size, material );
	}
}

// HUMANHEAD mdl:  Ripped from idAI for short invulnerability after returning from deathwalk
void hhPlayer::Event_AllowDamage( void ) {
	fl.takedamage = true;
}

void hhPlayer::Event_IgnoreDamage( void ) {
	fl.takedamage = false;
}

// Precompute all the weapons' info for faster HUD updates
void hhPlayer::SetupWeaponInfo() {
	const char *fireInfoName = NULL;
	const idDeclEntityDef *decl = NULL;
	const char *ammoName = NULL;
	float maxAmmo;

	memset(weaponInfo, 0, sizeof(weaponInfo_t)*15);
	memset(altWeaponInfo, 0, sizeof(weaponInfo_t)*15);

	for (int ix=0; ix<15; ix++) {
		const char *weaponClassName = spawnArgs.GetString( va( "def_weapon%d", ix ), NULL );
		if ( weaponClassName && *weaponClassName ) {

			const idDeclEntityDef *weaponObjDecl = gameLocal.FindEntityDef( weaponClassName, false );
			if ( weaponObjDecl ) {
				fireInfoName = weaponObjDecl->dict.GetString("def_fireInfo");
				decl = gameLocal.FindEntityDef( fireInfoName, false );
				if ( decl ) {
					weaponInfo[ix].ammoType = inventory.AmmoIndexForAmmoClass( decl->dict.GetString( "ammoType" ) );
					weaponInfo[ix].ammoRequired = decl->dict.GetInt("ammoRequired");
					weaponInfo[ix].ammoLow = decl->dict.GetInt("lowAmmo");

					ammoName = idWeapon::GetAmmoNameForNum( weaponInfo[ix].ammoType );
					maxAmmo = inventory.MaxAmmoForAmmoClass( this, ammoName );
					weaponInfo[ix].ammoMax = max(1, maxAmmo);
				}

				fireInfoName = weaponObjDecl->dict.GetString("def_altFireInfo");
				decl = gameLocal.FindEntityDef( fireInfoName, false );
				if ( decl ) {
					altWeaponInfo[ix].ammoType = inventory.AmmoIndexForAmmoClass( decl->dict.GetString( "ammoType" ) );
					altWeaponInfo[ix].ammoRequired = decl->dict.GetInt("ammoRequired");
					altWeaponInfo[ix].ammoLow = decl->dict.GetInt("lowAmmo");

					ammoName = idWeapon::GetAmmoNameForNum( altWeaponInfo[ix].ammoType );
					maxAmmo = inventory.MaxAmmoForAmmoClass( this, ammoName );
					altWeaponInfo[ix].ammoMax = max(1, maxAmmo);
				}
			}
		}
	}
}

/*
===============
hhPlayer::ThrowGrenade
HUMANHEAD bjk
===============
*/
void hhPlayer::ThrowGrenade( void ) {
	idMat3 axis;
	idVec3 muzzle;

	if( inventory.HasAmmo(inventory.AmmoIndexForAmmoClass( "ammo_crawler" ), 1) == false )
		return;

	if (IsSpiritOrDeathwalking() || InVehicle() || bReallyDead) {
		return;
	}

	if ( privateCameraView || !weaponEnabled || spectating || gameLocal.inCinematic || health < 0 || gameLocal.isClient )
		return;

	if( weapon.IsValid() ) {
		if ( inventory.weapons & ( 1 << 12 ) && currentWeapon != 12 && currentWeapon != 3 && idealWeapon == currentWeapon ) {
			idealWeapon = 12;
			previousWeapon = currentWeapon;
		}
		else if( currentWeapon == 3 ) {
			FireWeapon();
			usercmd.buttons = usercmd.buttons | BUTTON_ATTACK;
		}
	}
}

//HUMANHEAD bjk
void hhPlayer::Event_ReturnToWeapon() {
	const char *weap;

	if ( !weaponEnabled || spectating || gameLocal.inCinematic || health < 0 ) {
		idThread::ReturnInt(0);
		return;
	}

	if ( ( previousWeapon < 0 ) || ( previousWeapon >= MAX_WEAPONS ) ) {
		idThread::ReturnInt(0);
		return;
	}

	if ( gameLocal.isClient ) {
		idThread::ReturnInt(0);
		return;
	}

	weap = spawnArgs.GetString( va( "def_weapon%d", previousWeapon ) );
	if ( !weap[ 0 ] ) {
		gameLocal.Printf( "Invalid weapon\n" );
		idThread::ReturnInt(0);
		return;
	}

	if ( inventory.weapons & ( 1 << previousWeapon ) ) {
		idealWeapon = previousWeapon;
	}

	idThread::ReturnInt(1);
}

//HUMANHEAD rww
void hhPlayer::Event_CanAnimateTorso(void) {
	if (!gameLocal.isMultiplayer) { //don't worry about it
		idThread::ReturnInt(1);
		return;
	}

	if (!weapon.IsValid() || !weapon->IsType(hhWeapon::Type)) { //bad
		idThread::ReturnInt(0);
		return;
	}

	idThread::ReturnInt(1);
}

void hhPlayer::Show(void) {
	idActor::Show();

	hhWeapon *weap;
	weap = weapon.GetEntity();
	if ( weap ) {
		if (!IsLocked(currentWeapon)) {
			weap->ShowWorldModel();
		} else {
			weap->HideWorldModel();
		}
	}
}