// Copyright (C) 2007 Id Software, Inc.
//

#include "precompiled.h"
#pragma hdrstop

#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "PredictionErrorDecay.h"

#ifdef PREDICTION_ERROR_DECAY_DEBUG

idCVar net_debugPredictionError( "net_debugPredictionError", "0", CVAR_BOOL | CVAR_GAME | CVAR_CHEAT, "dump debugging information about the prediction error decay" );
int sdPredictionErrorDecay_Origin::pedDebugCount = 0;
int sdPredictionErrorDecay_Angles::pedDebugCount = 0;

#endif

idCVar net_predictionErrorDecay( "net_predictionErrorDecay", "1", CVAR_BOOL | CVAR_GAME | CVAR_NOCHEAT, "Enable/disable prediction error decay" );
idCVar net_limitApparentVelocity( "net_limitApparentVelocity", "1", CVAR_BOOL | CVAR_GAME | CVAR_NOCHEAT, "limit the apparent velocity of objects in prediction to realistic levels" );
idCVar net_limitApparentMaxLagAllowance( "net_limitApparentMaxLagAllowance", "0.25", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "fraction of the current physics speed added to the maximum apparent speed due to client lag" );
idCVar net_limitApparentMaxErrorAllowance( "net_limitApparentMaxErrorAllowance", "0.25", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "fraction of the current physics speed added to the maximum apparent speed due to client prediction error" );
idCVar net_limitApparentMinSpeed( "net_limitApparentMinSpeed", "200", CVAR_FLOAT | CVAR_GAME | CVAR_NOCHEAT, "minimum value for maximum apparent speed to reach" );

#define ENABLE_JP_FLOAT_CHECKS
#if defined( ENABLE_JP_FLOAT_CHECKS )
	#undef FLOAT_CHECK_BAD
	#undef VEC_CHECK_BAD

#define FLOAT_CHECK_BAD( x ) \
	( FLOAT_IS_NAN( x ) || FLOAT_IS_INF( x ) || FLOAT_IS_IND( x ) || FLOAT_IS_DENORMAL( x ) )

//	if ( FLOAT_IS_NAN( x ) || FLOAT_IS_INF( x ) || FLOAT_IS_IND( x ) || FLOAT_IS_DENORMAL( x ) ) \
//	{ \
//	gameLocal.Warning( "Bad floating point number in %s: %i", __FILE__, __LINE__ ); \
//	}


	#define VEC_CHECK_BAD( vec ) ( FLOAT_CHECK_BAD( ( vec ).x ) || FLOAT_CHECK_BAD( ( vec ).y ) || FLOAT_CHECK_BAD( ( vec ).z ) )
	#define MAT_CHECK_BAD( m ) ( VEC_CHECK_BAD( m[ 0 ] ) || VEC_CHECK_BAD( m[ 1 ] ) || VEC_CHECK_BAD( m[ 2 ] ) )
#else
	#define MAT_CHECK_BAD( m )
#endif

const float MAX_PREDICTION_TIME_OFFSET = 3.f;

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

	Quartic spline utility classes

===============================================================================
*/
class sdQuarticFunction {
public:
	float A, B, C, D, E;

	inline void Construct( float x0, float dx0, float ddx0, float x1, float dx1 ) {
		E = x0;
		D = dx0;
		C = ddx0 * 0.5f;
		B = 4.0f*x1 - 2.0f*C - 3.0f*D - 4.0f*E - dx1;
		A = x1 - B - C - D - E;
	}

	inline float EvaluateX( float t, float t2, float t3, float t4 ) const {
		return A*t4 + B*t3 + C*t2 + D*t + E;
	}
	inline float EvaluateDX( float t, float t2, float t3 ) const {
		return 4.0f*A*t3 + 3.0f*B*t2 + 2.0f*C*t + D;
	}
	inline float EvaluateDDX( float t, float t2 ) const {
		return 12.0f*A*t2 + 6.0f*B*t + 2.0f*C;
	}
};

class sdQuarticSpline {
public:
	sdQuarticFunction x, y, z;

	inline void Construct( const idVec3& x0, const idVec3& dx0, const idVec3& ddx0, const idVec3& x1, const idVec3& dx1 ) {
		x.Construct( x0.x, dx0.x, ddx0.x, x1.x, dx1.x );
		y.Construct( x0.y, dx0.y, ddx0.y, x1.y, dx1.y );
		z.Construct( x0.z, dx0.z, ddx0.z, x1.z, dx1.z );
	}

	inline idVec3 EvaluateX( float t, float t2, float t3, float t4 ) const {
		return idVec3( x.EvaluateX( t, t2, t3, t4 ), y.EvaluateX( t, t2, t3, t4 ), z.EvaluateX( t, t2, t3, t4 ) );
	}
	inline idVec3 EvaluateDX( float t, float t2, float t3 ) const {
		return idVec3( x.EvaluateDX( t, t2, t3 ), y.EvaluateDX( t, t2, t3 ), z.EvaluateDX( t, t2, t3 ) );
	}
	inline idVec3 EvaluateDDX( float t, float t2 ) const {
		return idVec3( x.EvaluateDDX( t, t2 ), y.EvaluateDDX( t, t2 ), z.EvaluateDDX( t, t2 ) );
	}
};

class sdQuarticAngleSpline {
public:
	sdQuarticFunction pitch, yaw, roll;
	idAngles baseAngles;

	inline void Construct( const idAngles& x0, const idAngles& dx0, const idAngles& ddx0, const idAngles& x1, const idAngles& dx1 ) {
		baseAngles = x0;

		// angles wrap around
		idAngles diffAngles = x1 - x0;
		//diffAngles.Normalize180();

		pitch.Construct( ang_zero.pitch, dx0.pitch, ddx0.pitch, diffAngles.pitch, dx1.pitch );
		yaw.Construct( ang_zero.yaw, dx0.yaw, ddx0.yaw, diffAngles.yaw, dx1.yaw );
		roll.Construct( ang_zero.roll, dx0.roll, ddx0.roll, diffAngles.roll, dx1.roll );
	}

	inline idAngles EvaluateX( float t, float t2, float t3, float t4 ) const {
		return idAngles( pitch.EvaluateX( t, t2, t3, t4 ), yaw.EvaluateX( t, t2, t3, t4 ), roll.EvaluateX( t, t2, t3, t4 ) ) + baseAngles;
	}
	inline idAngles EvaluateDX( float t, float t2, float t3 ) const {
		return idAngles( pitch.EvaluateDX( t, t2, t3 ), yaw.EvaluateDX( t, t2, t3 ), roll.EvaluateDX( t, t2, t3 ) );
	}
	inline idAngles EvaluateDDX( float t, float t2 ) const {
		return idAngles( pitch.EvaluateDDX( t, t2 ), yaw.EvaluateDDX( t, t2 ), roll.EvaluateDDX( t, t2 ) );
	}
};



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

	sdPredictionErrorDecay_Origin

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

/*
===============
sdPredictionErrorDecay_Origin::sdPredictionErrorDecay_Origin
===============
*/
sdPredictionErrorDecay_Origin::sdPredictionErrorDecay_Origin( void ) {
	lastReturnedOrigin.Zero();
	lastReturnedVelocity.Zero();
	lastReturnedAcceleration.Zero();

	networkTime = 0;
	networkOrigin.Zero();

	lastNetworkTime = 0;
	lastNetworkOrigin.Zero();

	lastLastNetworkTime = 0;
	lastLastNetworkOrigin.Zero();

	networkPacketDelay = 0;
	lastUpdateTime = 0;
	lastDecayTime = 0;

	isNew = true;
	owner = NULL;
	
	numDuplicates = 0;
	lastDuplicateTime = 0;
	isStationary = true;

#ifdef PREDICTION_ERROR_DECAY_DEBUG
	debugFile = NULL;
#endif
}

/*
===============
sdPredictionErrorDecay_Origin::~sdPredictionErrorDecay_Origin
===============
*/
sdPredictionErrorDecay_Origin::~sdPredictionErrorDecay_Origin( void ) {
#ifdef PREDICTION_ERROR_DECAY_DEBUG
	if ( debugFile != NULL ) {
		fileSystem->CloseFile( debugFile );
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Origin::Init
===============
*/
void sdPredictionErrorDecay_Origin::Init( idEntity* _owner ) {
	owner = _owner;

#ifdef PREDICTION_ERROR_DECAY_DEBUG
	myIndex = -1;
	if ( net_debugPredictionError.GetBool() && debugFile == NULL && _owner->entityNumber == 0 ) {
		debugFile = fileSystem->OpenFileWrite( va( "ped_origin_%i.csv", pedDebugCount++ ) );
		if ( debugFile != NULL ) {
			myIndex = pedDebugCount - 1;

			debugFile->Printf( "entNum,currentTime,prevTime,networkPacketDelay,timeSinceNewPacket," );
			debugFile->Printf( "matchingTime," );
			debugFile->Printf( "netOrigin.x,netOrigin.y,netOrigin.z,renderOrigin.x,renderOrigin.y,renderOrigin.z," );
			debugFile->Printf( "resultOrigin.x,resultOrigin.y,resultOrigin.z," );
			debugFile->Printf( "futureSpot.x,futureSpot.y,futureSpot.z," );
			debugFile->Printf( "futureVelocity.x,futureVelocity.y,futureVelocity.z," );
			debugFile->Printf( "lastNetworkTime,lastNetworkOrigin.x,lastNetworkOrigin.y,lastNetworkOrigin.z," );
			debugFile->Printf( "lastLastNetworkTime,lastLastNetworkOrigin.x,lastLastNetworkOrigin.y,lastLastNetworkOrigin.z," );
			debugFile->Printf( "\n" );
		}
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Origin::Reset
===============
*/
void sdPredictionErrorDecay_Origin::Reset( const idVec3& newOrigin ) {
	lastReturnedOrigin = newOrigin;
	lastReturnedVelocity.Zero();
	lastReturnedAcceleration.Zero();

	networkTime = gameLocal.time;
	networkOrigin = newOrigin;

	lastNetworkTime = networkTime;
	lastNetworkOrigin = networkOrigin;

	lastLastNetworkTime = lastNetworkTime;
	lastLastNetworkOrigin = lastNetworkOrigin;

	numDuplicates = 0;
	lastDuplicateTime = 0;
	isStationary = true;

	lastDecayTime = gameLocal.time - gameLocal.msec;
}

/*
===============
sdPredictionErrorDecay_Origin::Update
===============
*/
void sdPredictionErrorDecay_Origin::Update( const sdPredictionErrorDecay_Origin::CustomDecayInfo* customInfo ) {
	lastUpdateTime = gameLocal.time;

	bool hasLocalPhysics;
	int prediction;
	int packetSpread;
	idVec3 origin;

	if ( customInfo == NULL ) {
		hasLocalPhysics = !owner->IsPhysicsInhibited();
		prediction = networkSystem->ClientGetPrediction();
		packetSpread = owner->aorPacketSpread;
		origin = owner->GetPhysics()->GetOrigin();
	} else {
		hasLocalPhysics = customInfo->hasLocalPhysics;
		prediction = customInfo->currentPrediction;
		packetSpread = customInfo->packetSpread;
		origin = customInfo->origin;
	}

	if ( hasLocalPhysics ) {
		int timeSinceNewPacket = gameLocal.time - networkTime;
		timeSinceNewPacket -= gameLocal.msec;
		timeSinceNewPacket -= prediction;
		int reAddTime = packetSpread + packetSpread / 5;
		if ( reAddTime < gameLocal.msec * 4 ) {
			reAddTime = gameLocal.msec * 4;
		}

		if ( timeSinceNewPacket > reAddTime ) {
			// insert a new "packet" if its been too long and we're running physics locally
			// its generally close enough that this all averages out
			OnNewInfo( origin, gameLocal.time, customInfo );
		}
	}

#ifdef PREDICTION_ERROR_DECAY_DEBUG
	if ( net_debugPredictionError.GetBool() && debugFile == NULL && owner->entityNumber == 0 ) {
		debugFile = fileSystem->OpenFileWrite( va( "ped_origin_%i.csv", pedDebugCount++ ) );
		if ( debugFile != NULL ) {
			myIndex = pedDebugCount - 1;

			debugFile->Printf( "entNum,currentTime,prevTime,networkPacketDelay,timeSinceNewPacket," );
			debugFile->Printf( "matchingTime," );
			debugFile->Printf( "netOrigin.x,netOrigin.y,netOrigin.z,renderOrigin.x,renderOrigin.y,renderOrigin.z," );
			debugFile->Printf( "resultOrigin.x,resultOrigin.y,resultOrigin.z," );
			debugFile->Printf( "futureSpot.x,futureSpot.y,futureSpot.z," );
			debugFile->Printf( "futureVelocity.x,futureVelocity.y,futureVelocity.z," );
			debugFile->Printf( "lastNetworkTime,lastNetworkOrigin.x,lastNetworkOrigin.y,lastNetworkOrigin.z," );
			debugFile->Printf( "lastLastNetworkTime,lastLastNetworkOrigin.x,lastLastNetworkOrigin.y,lastLastNetworkOrigin.z," );
			debugFile->Printf( "\n" );
		}
	}
	if ( !net_debugPredictionError.GetBool() && debugFile != NULL ) {
		fileSystem->CloseFile( debugFile );
		debugFile = NULL;
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Origin::LimitApparentVelocity
===============
*/
float sdPredictionErrorDecay_Origin::LimitApparentVelocity( const idVec3& oldOrigin, const idVec3& idealNewOrigin, idVec3& newOrigin, const idVec3& physicsVelocity, int currentPrediction ) {
	idVec3 apparentVelocity = ( newOrigin - oldOrigin ) / MS2SEC( gameLocal.msec );
	float apparentSpeedSqr = apparentVelocity.LengthSqr();

	float error = ( idealNewOrigin - oldOrigin ).Length();
	float localSpeed = physicsVelocity.Length();
	float speedAllowanceDueToLag = Min( localSpeed * net_limitApparentMaxLagAllowance.GetFloat(), 0.5f * currentPrediction * localSpeed / 350.0f );
	float speedAllowanceDueToError = Min( localSpeed * net_limitApparentMaxErrorAllowance.GetFloat(), 2.0f * error * localSpeed / 350.0f );
	float maxSpeed = localSpeed + speedAllowanceDueToLag + speedAllowanceDueToError;
	maxSpeed = Max( net_limitApparentMinSpeed.GetFloat(), Min( localSpeed * 1.25f, maxSpeed ) );

	if ( apparentSpeedSqr > Square( maxSpeed ) && apparentSpeedSqr > idMath::FLT_EPSILON ) {
		// apparent velocity is too high
		// try to tone that back linearly
		float apparentSpeed = idMath::Sqrt( apparentSpeedSqr );
		float lerpValue = maxSpeed / apparentSpeed;

		newOrigin = Lerp( oldOrigin, newOrigin, lerpValue );
		return lerpValue;
	}

	return 1.0f;
}

/*
===============
sdPredictionErrorDecay_Origin::Decay
===============
*/
void sdPredictionErrorDecay_Origin::Decay( idVec3& renderOrigin, const sdPredictionErrorDecay_Origin::CustomDecayInfo* customInfo ) {
	//
	// TWTODO: This whole function needs a good old cleanup!!
	//
	if ( IsNew() ) {
		return;
	}

	assert( owner );

	if ( !net_predictionErrorDecay.GetBool() ) {
		Reset( renderOrigin );
		return;
	}

	if ( gameLocal.time <= lastDecayTime || !gameLocal.isNewFrame || gameLocal.msec == 0 || !owner->fl.allowPredictionErrorDecay ) {
		renderOrigin = lastReturnedOrigin;
		return;
	}

	idVec3 predictedOrigin = renderOrigin;

	//
	// Collect information to be used
	//
	bool	hasLocalPhysics;
	bool	isPlayer;
	int		currentPrediction;
	int		packetSpread;
	bool	boxDecayClip;
	bool	pointDecayClip;
	bool	heightMapDecayClip;
	idVec3	limitVelocity;
	bool	hasGroundContacts;
	float	physicsCutoffSqr;
	float	ownerAorDistSqr;

	if ( customInfo == NULL ) {
		hasLocalPhysics = !owner->IsPhysicsInhibited();
		isPlayer = owner->IsType( idPlayer::Type );
		currentPrediction = networkSystem->ClientGetPrediction();
		packetSpread = owner->aorPacketSpread;
		boxDecayClip = ( owner->aorFlags & AOR_BOX_DECAY_CLIP ) != 0;
		pointDecayClip = ( owner->aorFlags & AOR_POINT_DECAY_CLIP ) != 0;
		heightMapDecayClip = ( owner->aorFlags & AOR_HEIGHTMAP_DECAY_CLIP ) != 0;
		limitVelocity = owner->GetPhysics()->GetLinearVelocity();
		hasGroundContacts = owner->GetPhysics()->HasGroundContacts();
		physicsCutoffSqr = 1.0f;
		ownerAorDistSqr = 0.0f;
		if ( owner->aorLayout != NULL ) {
			physicsCutoffSqr = owner->aorLayout->GetPhysicsCutoffSqr();
			ownerAorDistSqr = owner->aorDistanceSqr;
		}
	} else {
		// using custom info
		hasLocalPhysics		= customInfo->hasLocalPhysics;
		isPlayer			= customInfo->isPlayer;
		currentPrediction	= customInfo->currentPrediction;
		packetSpread		= customInfo->packetSpread;
		boxDecayClip		= customInfo->boxDecayClip;
		pointDecayClip		= customInfo->pointDecayClip;
		heightMapDecayClip	= customInfo->heightMapDecayClip;
		limitVelocity		= customInfo->limitVelocity;
		hasGroundContacts	= customInfo->hasGroundContacts;
		physicsCutoffSqr	= customInfo->physicsCutoffSqr;
		ownerAorDistSqr		= customInfo->ownerAorDistSqr;
	}

	if ( networkPacketDelay > 0 && networkTime != lastNetworkTime ) {

		// TODO: clean up this timing stuff!
		int timeSinceNewPacket = gameLocal.time - networkTime;
		if ( timeSinceNewPacket < gameLocal.msec ) {
			timeSinceNewPacket = gameLocal.msec;
		}

		int lerpDuration = packetSpread*2;
		if ( lerpDuration < gameLocal.msec ) {
			lerpDuration = gameLocal.msec;
		}

		int matchingTimeInt = gameLocal.msec * 3;
		if ( matchingTimeInt < lerpDuration ) {
			matchingTimeInt = lerpDuration;
		}

		float matchingTime = MS2SEC( matchingTimeInt );

		//
		// Predict a position and velocity for the future
		//
		idVec3 futureVelocity;
		int timeOffset = timeSinceNewPacket;

		idVec3 hasPhysicsVelocity = vec3_origin;
		idVec3 noPhysicsVelocity = vec3_origin;

		//
		// estimate velocity from local physics
		if ( hasLocalPhysics ) {
			if ( !isStationary && timeSinceNewPacket + ( networkTime - lastNetworkTime ) > 0 ) {
				if ( isPlayer && timeSinceNewPacket > 0 ) {
					hasPhysicsVelocity = ( predictedOrigin - networkOrigin ) / MS2SEC( timeSinceNewPacket );
				} else {
					// velocity averaged over last couple of packets plus the prediction so far
					hasPhysicsVelocity = ( predictedOrigin - lastNetworkOrigin ) / MS2SEC( timeSinceNewPacket + ( networkTime - lastNetworkTime )  );
				}
			} else {
				hasPhysicsVelocity = ( predictedOrigin - networkOrigin ) / MS2SEC( gameLocal.msec * 4 );
				timeOffset = gameLocal.msec * 5;
			}
		}

		//
		// estimate velocity from what has been sent on the network
		{
			idVec3 networkVelocity = ( networkOrigin - lastNetworkOrigin ) / MS2SEC( networkTime - lastNetworkTime );

			if ( lastNetworkTime != lastLastNetworkTime ) {
				idVec3 lastNetworkVelocity = ( lastNetworkOrigin - lastLastNetworkOrigin ) / MS2SEC( lastNetworkTime - lastLastNetworkTime );

				float recentBiasValue = idMath::ClampFloat( 0.0f, 1.0f, timeSinceNewPacket / ( lerpDuration * 0.5f ) );
				noPhysicsVelocity = Lerp( lastNetworkVelocity, networkVelocity, 0.5f + 0.5f * recentBiasValue );

				idVec3 networkAcceleration = ( networkVelocity - lastNetworkVelocity ) / MS2SEC( 0.5f * ( ( networkTime + lastNetworkTime ) - ( lastNetworkTime + lastLastNetworkTime )  ) );

				// decay networkAcceleration based on how long its been since the acceleration took place
				networkAcceleration *= 1.0f - recentBiasValue;

				noPhysicsVelocity += networkAcceleration * MS2SEC( timeSinceNewPacket );
			} else {
				noPhysicsVelocity = networkVelocity;
			}

			// scale back a bit for less overshoot
			noPhysicsVelocity *= 0.6f;
			
			// decay velocity down if timeSinceNewPacket is getting big
			int velocityDecayStart = lerpDuration + lerpDuration / 2 + currentPrediction;
			if ( timeSinceNewPacket > velocityDecayStart ) {
				float scale = 1.0f - idMath::ClampFloat( 0.0f, 1.0f, ( timeSinceNewPacket - velocityDecayStart ) / ( lerpDuration * 0.5f ) );
				noPhysicsVelocity *= scale;
			}
		}


		// blend the two together based on distance to the physics cutoff point
		// to smooth the change between prediction modes
		float lerpToPhysicsCutoff;
		if ( owner->aorLayout != NULL ) {
			if ( physicsCutoffSqr > idMath::FLT_EPSILON ) {
				lerpToPhysicsCutoff = idMath::ClampFloat( 0.0f, 1.0f, ownerAorDistSqr / physicsCutoffSqr );
				futureVelocity = Lerp( hasPhysicsVelocity, noPhysicsVelocity, lerpToPhysicsCutoff );
			} else {
				lerpToPhysicsCutoff = 1.0f;
				futureVelocity = noPhysicsVelocity;
			}
		} else {
			if ( hasLocalPhysics ) {
				lerpToPhysicsCutoff = 0.0f;
				futureVelocity = hasPhysicsVelocity;
			} else {
				lerpToPhysicsCutoff = 1.0f;
				futureVelocity = noPhysicsVelocity;
			}
		}

		idVec3 futureOrigin = networkOrigin + futureVelocity * ( matchingTime + MS2SEC( timeOffset ) );

		if ( !hasLocalPhysics && ( boxDecayClip || pointDecayClip || heightMapDecayClip ) ) {
			// crude clipping to try to stop it dipping through the ground
			idBounds bounds = owner->GetPhysics()->GetBounds();
			idVec3 center = bounds.GetCenter(); 
			idVec3 size = bounds.GetSize();
			for ( int i = 0; i < 3; i++ ) {
				if ( size[ i ] > 48.0f ) {
					size[ i ] -= 16.0f;
				}
			}
			
			bounds = idBounds( center - size * 0.5f, center + size * 0.5f );

			idVec3 direction = futureOrigin - predictedOrigin;
			float distance = direction.Normalize();
			float sizeInDirection = idMath::Fabs( size * direction );

			// limit the length of the trace
			if ( distance > 512.0f ) {
				distance = 512.0f;
			}

			idVec3 rotatedCenter = center * owner->GetPhysics()->GetAxis();
			idVec3 start = rotatedCenter + predictedOrigin;
			idVec3 end = start + distance * direction;

			// TWTODO: use proper contents masks requested from the physics
			trace_t trace;
			if ( boxDecayClip ) {
				gameLocal.clip.TraceBounds( CLIP_DEBUG_PARMS trace, start, end, bounds, owner->GetPhysics()->GetAxis(), CONTENTS_SOLID | CONTENTS_VEHICLECLIP, owner );
			} else if ( pointDecayClip ) { 
				end += direction * sizeInDirection * 2.0f;
				gameLocal.clip.TracePoint( CLIP_DEBUG_PARMS trace, start, end, CONTENTS_SOLID | CONTENTS_VEHICLECLIP, owner );
			} else {
				end += direction * sizeInDirection * 2.0f;
				trace.fraction = 1.0f;
				trace.endpos = end;

				const sdPlayZone* playZoneHeight = gameLocal.GetPlayZone( start, sdPlayZone::PZF_HEIGHTMAP );
				if ( playZoneHeight != NULL ) {
					const sdHeightMapInstance& heightMap = playZoneHeight->GetHeightMap();
					if ( heightMap.IsValid() ) {
						trace.fraction = heightMap.TracePoint( start, end, trace.endpos );
						trace.c.normal.Set( 0.0f, 0.0f, 1.0f );
					}
				}
			}

			if ( trace.fraction < 1.0f ) {
				// scale back the velocity in the direction of the bump too
				futureVelocity -= ( futureVelocity * trace.c.normal * 0.95f ) * trace.c.normal;
				futureOrigin = networkOrigin + futureVelocity * ( matchingTime + MS2SEC( timeOffset ) );
			}
		}

		//
		// Construct & evaluate splines for output
		//
		float t = MS2SEC( gameLocal.msec ) / matchingTime;
		float spreadBasedScaleUp = Lerp( 1.0f, 1.5f, ( 1000 - lerpDuration + 150 ) / 1000.0f );
		t *= spreadBasedScaleUp;
		if ( t > 0.5f ) {
			t = 0.5f;
		}
		float t2 = t*t;
		float t3 = t2*t;
		float t4 = t2*t2;

		sdQuarticSpline spline;
		spline.Construct( lastReturnedOrigin, lastReturnedVelocity, lastReturnedAcceleration, futureOrigin, futureVelocity );
		idVec3 tweenOrigin = spline.EvaluateX( t, t2, t3, t4 );
		idVec3 tweenVelocity = spline.EvaluateDX( t, t2, t3 );
		idVec3 tweenAcceleration = spline.EvaluateDDX( t, t2 );

		//
		// Try to prevent the apparent velocity being unrealistic
		//
		if ( net_limitApparentVelocity.GetBool() ) {
			float originalTweenOriginZ = tweenOrigin.z;
			float originalTweenVelocityZ = tweenVelocity.z;
			float originalTweenAccelerationZ = tweenAcceleration.z;

			// since this does a bunch of masking to cover up jerking, can blend in more of what is REALLY happening
			tweenOrigin = Lerp( predictedOrigin, tweenOrigin, lerpToPhysicsCutoff );

			float lerpValue = LimitApparentVelocity( lastReturnedOrigin, predictedOrigin, tweenOrigin, 
													limitVelocity, currentPrediction );
			tweenVelocity = Lerp( lastReturnedVelocity, tweenVelocity, lerpValue );
			tweenAcceleration = Lerp( lastReturnedAcceleration, tweenAcceleration, lerpValue );

			if ( isPlayer ) {
				// HACK: players don't limit z velocity as much - looks really weird when they jump
				tweenOrigin.z = Lerp( tweenOrigin.z, originalTweenOriginZ, 0.75f );
				tweenVelocity.z = Lerp( tweenVelocity.z, originalTweenVelocityZ, 0.75f );
				tweenAcceleration.z = Lerp( tweenAcceleration.z, originalTweenAccelerationZ, 0.75f );
			}
		}

		if ( hasLocalPhysics ) {
			if ( hasGroundContacts ) {
				if ( tweenOrigin.z < predictedOrigin.z ) {
					tweenOrigin.z = predictedOrigin.z;
				}
			}
		}

		tweenOrigin.FixDenormals();
		tweenVelocity.FixDenormals();
		tweenAcceleration.FixDenormals();

		// cache output
		renderOrigin = tweenOrigin;
		lastReturnedOrigin = tweenOrigin;
		lastReturnedVelocity = tweenVelocity;
		lastReturnedAcceleration = tweenAcceleration;

		//
		// Debugging info
		//
	#ifdef PREDICTION_ERROR_DECAY_DEBUG
		if ( debugFile != NULL ) {
			if ( owner != NULL ) {
				debugFile->Printf( "%i,", owner->entityNumber );
			} else {
				debugFile->Printf( "-1," );
			}

			// timing
			debugFile->Printf( "%i,%i,%i,%i,", gameLocal.time, networkTime, networkPacketDelay, timeSinceNewPacket );
			debugFile->Printf( "%.2f,", matchingTime );

			// origin
			debugFile->Printf( "%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,", networkOrigin.x, networkOrigin.y, networkOrigin.z,
																predictedOrigin.x, predictedOrigin.y, predictedOrigin.z );
			debugFile->Printf( "%.2f,%.2f,%.2f,", renderOrigin.x, renderOrigin.y, renderOrigin.z );
			debugFile->Printf( "%.2f,%.2f,%.2f,", futureOrigin.x, futureOrigin.y, futureOrigin.z );
			debugFile->Printf( "%.2f,%.2f,%.2f,", futureVelocity.x, futureVelocity.y, futureVelocity.z );

			debugFile->Printf( "%i,%.2f,%.2f,%.2f,", lastNetworkTime, lastNetworkOrigin.x, lastNetworkOrigin.y, lastNetworkOrigin.z );
			debugFile->Printf( "%i,%.2f,%.2f,%.2f,", lastLastNetworkTime, lastLastNetworkOrigin.x, lastLastNetworkOrigin.y, lastLastNetworkOrigin.z );

			debugFile->Printf( "\n" );
		}
	#endif
	} else {
		// do nothing - it hasn't calibrated itself appropriately yet
		lastReturnedOrigin = renderOrigin;
	}

	lastDecayTime = gameLocal.time;

	// gracefully handle bad values
	// TWTODO: Proper fix!
	if ( VEC_CHECK_BAD( renderOrigin ) ) {
		gameLocal.Warning( "sdPredictionErrorDecay_Origin::Decay - Bad float!" );
		assert( false );
		renderOrigin = predictedOrigin;
		Reset( renderOrigin );
	}
}

/*
===============
sdPredictionErrorDecay_Origin::OnNewInfo
===============
*/
void sdPredictionErrorDecay_Origin::OnNewInfo( const idVec3& serverOrigin, int& time, const CustomDecayInfo* customInfo ) {
	assert( owner );

	if ( !net_predictionErrorDecay.GetBool() ) {
		return;
	}

	int newDelay = gameLocal.time - networkTime;

	int packetSpread = customInfo == NULL ? owner->aorPacketSpread : customInfo->packetSpread;
	bool physicsInhibited = customInfo == NULL ? owner->IsPhysicsInhibited() : !customInfo->hasLocalPhysics;
	if ( newDelay < packetSpread ) {
		if ( physicsInhibited ) {
			networkOrigin = serverOrigin;
			networkTime = time;
		}
		return;
	}

	// see if it falls beneath the interesting threshold
	float diffSqr = ( serverOrigin - networkOrigin ).LengthSqr();
	if ( diffSqr < Square( 0.5f ) ) {
		if ( diffSqr < idMath::FLT_EPSILON && time > lastDuplicateTime ) {
			// its basically identical to the last origin!
			numDuplicates++;
			lastDuplicateTime = time;
			if ( numDuplicates >= 2 ) {
				// 2 duplicates - we must be stationary
				isStationary = true;
			}
		}
		networkOrigin = serverOrigin;
		networkTime = time;
		return;
	}

	// see if the distance is too far - ie, looks like its a respawn or teleport that hasn't been
	// caught properly by a reset
	idVec3 velocity = owner->GetPhysics()->GetLinearVelocity();
	if ( customInfo != NULL ) {
		velocity = customInfo->limitVelocity;
	}

	float thresholdDistanceSqr = velocity.LengthSqr() * Square( 4.0f );
	thresholdDistanceSqr = Max( thresholdDistanceSqr, Square( 1024.0f ) );
	float returnedDiffSqr = ( serverOrigin - lastReturnedOrigin ).LengthSqr();
	if ( returnedDiffSqr > thresholdDistanceSqr ) {
		Reset( serverOrigin );
		return;
	}

	if ( isStationary ) {
		newDelay = packetSpread;
		isStationary = false;
		numDuplicates = 0;
	}

	if ( newDelay > 0 ) {
//		networkPacketDelay = ( newDelay + networkPacketDelay ) * 0.5f;
		networkPacketDelay = newDelay;
	}

	// don't let the delay get too big
	if ( networkPacketDelay > 1000 ) {
		networkPacketDelay = 1000;
	}

	if ( isNew ) {
		networkPacketDelay = 0;
		isNew = false;

		networkTime = time;
		networkOrigin = serverOrigin;

		lastNetworkTime = networkTime;
		lastNetworkOrigin = networkOrigin;

		lastLastNetworkTime = lastNetworkTime;
		lastLastNetworkOrigin = lastNetworkOrigin;
	} else {
		lastLastNetworkTime = lastNetworkTime;
		lastLastNetworkOrigin = lastNetworkOrigin;

		lastNetworkTime = networkTime;
		lastNetworkOrigin = networkOrigin;

		networkTime = time;
		networkOrigin = serverOrigin;
	}
}

/*
===============
sdPredictionErrorDecay_Origin::NeedsUpdate
===============
*/
bool sdPredictionErrorDecay_Origin::NeedsUpdate( void ) {
	return gameLocal.time >= lastDecayTime && !IsNew() && ( ( gameLocal.time - networkTime ) < SEC2MS( MAX_PREDICTION_TIME_OFFSET ) );
}






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

	sdPredictionErrorDecay_Angles

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



/*
===============
sdPredictionErrorDecay_Angles::sdPredictionErrorDecay_Angles
===============
*/
sdPredictionErrorDecay_Angles::sdPredictionErrorDecay_Angles( void ) {
	lastReturnedAngles.Zero();
	lastReturnedAngVelocity.Zero();
	lastReturnedAngAcceleration.Zero();

	networkTime = 0;
	networkAngles.Zero();

	lastNetworkTime = 0;
	lastNetworkAngles.Zero();

	lastLastNetworkTime = 0;
	lastLastNetworkAngles.Zero();

	networkPacketDelay = 0;
	lastUpdateTime = 0;
	lastDecayTime = 0;

	isNew = true;
	owner = NULL;
	
	numDuplicates = 0;
	lastDuplicateTime = 0;
	isStationary = true;

#ifdef PREDICTION_ERROR_DECAY_DEBUG
	debugFile = NULL;
#endif
}

/*
===============
sdPredictionErrorDecay_Angles::~sdPredictionErrorDecay_Angles
===============
*/
sdPredictionErrorDecay_Angles::~sdPredictionErrorDecay_Angles( void ) {
#ifdef PREDICTION_ERROR_DECAY_DEBUG
	if ( debugFile != NULL ) {
		fileSystem->CloseFile( debugFile );
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Angles::Init
===============
*/
void sdPredictionErrorDecay_Angles::Init( idEntity* _owner ) {
	owner = _owner;

#ifdef PREDICTION_ERROR_DECAY_DEBUG
	debugFile = NULL;
	if ( owner->IsType( idPlayer::Type ) && net_debugPredictionError.GetBool() ) {
		debugFile = fileSystem->OpenFileWrite( va( "ped_angles_%i.csv", pedDebugCount++ ) );
	}

	if ( debugFile != NULL ) {
		debugFile->Printf( "entNum,currentTime,prevTime,networkPacketDelay,timeSinceNewPacket," );
		debugFile->Printf( "netAngles.pitch,netAngles.yaw,netAngles.roll,renderAngles.pitch,renderAngles.yaw,renderAngles.roll," );
		debugFile->Printf( "resultAngles.pitch,resultAngles.yaw,resultAngles.roll," );
		debugFile->Printf( "\n" );
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Angles::Reset
===============
*/
void sdPredictionErrorDecay_Angles::Reset( const idMat3& newAxis ) {
	lastReturnedAngles = newAxis.ToAngles();
	lastReturnedAngVelocity.Zero();
	lastReturnedAngAcceleration.Zero();

	networkTime = gameLocal.time;
	networkAngles = newAxis.ToAngles();

	lastNetworkTime = networkTime;
	lastNetworkAngles = networkAngles;

	lastLastNetworkTime = lastNetworkTime;
	lastLastNetworkAngles = lastNetworkAngles;

	numDuplicates = 0;
	lastDuplicateTime = 0;
	isStationary = true;

	lastDecayTime = gameLocal.time - gameLocal.msec;
}

/*
===============
sdPredictionErrorDecay_Angles::Update
===============
*/
void sdPredictionErrorDecay_Angles::Update() {
	lastUpdateTime = gameLocal.time;

/*	bool hasLocalPhysics = !owner->IsPhysicsInhibited();
	if ( hasLocalPhysics ) {
		int timeSinceNewPacket = gameLocal.time - networkTime;
		timeSinceNewPacket -= gameLocal.msec;
		if ( timeSinceNewPacket > owner->aorPacketSpread + owner->aorPacketSpread / 5 ) {
			// insert a new "packet" if its been too long and we're running physics locally
			// its generally close enough that this all averages out
			OnNewInfo( owner->GetPhysics()->GetAxis() );
		}
	}
*/
#ifdef PREDICTION_ERROR_DECAY_DEBUG
	if ( net_debugPredictionError.GetBool() && debugFile == NULL ) {
		debugFile = fileSystem->OpenFileWrite( va( "ped_angles_%i.csv", pedDebugCount++ ) );
		if ( debugFile != NULL ) {
			debugFile->Printf( "entNum,currentTime,prevTime,networkPacketDelay,timeSinceNewPacket," );
			debugFile->Printf( "netAngles.pitch,netAngles.yaw,netAngles.roll,renderAngles.pitch,renderAngles.yaw,renderAngles.roll," );
			debugFile->Printf( "resultAngles.pitch,resultAngles.yaw,resultAngles.roll," );
			debugFile->Printf( "\n" );
		}
	}
	if ( !net_debugPredictionError.GetBool() && debugFile != NULL ) {
		fileSystem->CloseFile( debugFile );
		debugFile = NULL;
	}
#endif
}

/*
===============
sdPredictionErrorDecay_Angles::Decay
===============
*/
void sdPredictionErrorDecay_Angles::Decay( idMat3& renderAxis, bool yawOnly ) {
	//
	// TWTODO: This whole function needs a good old cleanup!!
	//

	if ( IsNew() ) {
		return;
	}

	assert( owner );

	if ( !net_predictionErrorDecay.GetBool() ) {
		Reset( renderAxis );
		return;
	}

	if ( gameLocal.time <= lastDecayTime || !gameLocal.isNewFrame || gameLocal.msec == 0 || !owner->fl.allowPredictionErrorDecay ) {
		renderAxis = lastReturnedAngles.ToMat3();
		return;
	}

	idMat3 predictedAxes = renderAxis;
	idAngles predictedAngles = predictedAxes.ToAngles();
	predictedAngles = networkAngles - ( networkAngles - predictedAngles ).Normalize180();

	bool hasLocalPhysics = !owner->IsPhysicsInhibited();
	if ( networkPacketDelay > 0 && networkTime != lastNetworkTime ) {

		// TODO: clean up this timing stuff!
		int timeSinceNewPacket = gameLocal.time - networkTime;
		if ( timeSinceNewPacket < gameLocal.msec ) {
			timeSinceNewPacket = gameLocal.msec;
		}

		int lerpDuration = owner->aorPacketSpread*2;
		if ( lerpDuration < gameLocal.msec ) {
			lerpDuration = gameLocal.msec;
		}

		int matchingTimeInt = gameLocal.msec * 3;
		if ( matchingTimeInt < lerpDuration ) {
			matchingTimeInt = lerpDuration;
		}

		float matchingTime = MS2SEC( matchingTimeInt );

		//
		// Predict an angles and angular velocity for the future
		//
		idAngles futureAngVelocity;
		int timeOffset = timeSinceNewPacket;

		idAngles hasPhysicsVelocity = ang_zero;
		idAngles noPhysicsVelocity = ang_zero;

		int currentPrediction = networkSystem->ClientGetPrediction();

		//
		// estimate velocity from local physics
		if ( hasLocalPhysics ) {
			if ( !isStationary && timeSinceNewPacket + ( networkTime - lastNetworkTime ) > 0 ) {
				if ( owner->IsType( idPlayer::Type ) && timeSinceNewPacket > 0 ) {
					hasPhysicsVelocity = ( predictedAngles - networkAngles) / MS2SEC( timeSinceNewPacket );
				} else {
					// velocity averaged over last couple of packets plus the prediction so far
					hasPhysicsVelocity = ( predictedAngles - lastNetworkAngles ) / MS2SEC( timeSinceNewPacket + ( networkTime - lastNetworkTime )  );
				}
			} else {
				hasPhysicsVelocity = ( predictedAngles - networkAngles ) / MS2SEC( gameLocal.msec * 4 );
				timeOffset = gameLocal.msec * 5;
			}
		} 
		
		//
		// estimate velocity from what has been sent on the network
		{
			idAngles networkAngVelocity = ( networkAngles - lastNetworkAngles ) / MS2SEC( networkTime - lastNetworkTime );

			if ( lastNetworkTime != lastLastNetworkTime ) {
				idAngles lastNetworkAngVelocity = ( lastNetworkAngles - lastLastNetworkAngles ) / MS2SEC( lastNetworkTime - lastLastNetworkTime );

				float recentBiasValue = idMath::ClampFloat( 0.0f, 1.0f, timeSinceNewPacket / ( lerpDuration * 0.5f ) );
				noPhysicsVelocity = Lerp( lastNetworkAngVelocity, networkAngVelocity, 0.5f + 0.5f * recentBiasValue );

				idAngles networkAngAcceleration = ( networkAngVelocity - lastNetworkAngVelocity ) / MS2SEC( 0.5f * ( ( networkTime + lastNetworkTime ) - ( lastNetworkTime + lastLastNetworkTime )  ) );

				// decay networkAngAcceleration based on how long its been since the acceleration took place
				networkAngAcceleration *= 1.0f - recentBiasValue;

				noPhysicsVelocity += networkAngAcceleration * MS2SEC( timeSinceNewPacket );
			} else {
				noPhysicsVelocity = networkAngVelocity;
			}

			// scale back a bit for less overshoot
			noPhysicsVelocity.pitch *= 0.1f;
			noPhysicsVelocity.yaw *= 0.4f;
			noPhysicsVelocity.roll *= 0.1f;

			// decay velocities down if timeSinceNewPacket is getting big
			int velocityDecayStart = lerpDuration + lerpDuration / 2 + currentPrediction;
			if ( timeSinceNewPacket > velocityDecayStart ) {
				float scale = 1.0f - idMath::ClampFloat( 0.0f, 1.0f, ( timeSinceNewPacket - velocityDecayStart ) / ( lerpDuration * 0.5f ) );
				noPhysicsVelocity *= scale;
			}
		}


		// blend the two together based on distance to the physics cutoff point
		// to smooth the change between prediction modes
		if ( owner->aorLayout != NULL ) {
			float physicsCutoffSqr = owner->aorLayout->GetPhysicsCutoffSqr();
			if ( physicsCutoffSqr > idMath::FLT_EPSILON ) {
				float lerpValue = idMath::ClampFloat( 0.0f, 1.0f, owner->aorDistanceSqr / physicsCutoffSqr );
				futureAngVelocity = Lerp( hasPhysicsVelocity, noPhysicsVelocity, lerpValue );
			} else {
				futureAngVelocity = noPhysicsVelocity;
			}
		} else {
			if ( hasLocalPhysics ) {
				futureAngVelocity = hasPhysicsVelocity;
			} else {
				futureAngVelocity = noPhysicsVelocity;
			}
		}

		idAngles futureAngles = networkAngles + futureAngVelocity * ( matchingTime + MS2SEC( timeOffset ) );

		//
		// Construct & evaluate splines for output
		//
		float t = MS2SEC( gameLocal.msec ) / matchingTime;
		float spreadBasedScaleUp = Lerp( 1.0f, 1.5f, ( 1000 - lerpDuration + 150 ) / 1000.0f );
		t *= spreadBasedScaleUp;
		if ( t > 0.5f ) {
			t = 0.5f;
		}
		float t2 = t*t;
		float t3 = t2*t;
		float t4 = t2*t2;

		// angles
		idAngles tweenAngles = ang_zero;
		idAngles tweenAngVelocity = ang_zero;
		idAngles tweenAngAcceleration = ang_zero;

		if ( !yawOnly ) {
			sdQuarticAngleSpline angSpline;
			angSpline.Construct( lastReturnedAngles, lastReturnedAngVelocity, lastReturnedAngAcceleration, futureAngles, futureAngVelocity );
			tweenAngles = angSpline.EvaluateX( t, t2, t3, t4 );
			tweenAngVelocity = angSpline.EvaluateDX( t, t2, t3 );
			tweenAngAcceleration = angSpline.EvaluateDDX( t, t2 );
		} else {
			// player only operates on yaw
			float diffYaw = idMath::AngleNormalize180( futureAngles.yaw - lastReturnedAngles.yaw );
			sdQuarticFunction yaw;
			yaw.Construct( 0.0f, lastReturnedAngVelocity.yaw, lastReturnedAngAcceleration.yaw, diffYaw, futureAngVelocity.yaw );
			tweenAngles.yaw = yaw.EvaluateX( t, t2, t3, t4 ) + lastReturnedAngles.yaw;
			tweenAngVelocity.yaw = yaw.EvaluateDX( t, t2, t3 );
			tweenAngAcceleration.yaw = yaw.EvaluateDDX( t, t2 );
		}

		tweenAngles.FixDenormals();
		tweenAngVelocity.FixDenormals();
		tweenAngAcceleration.FixDenormals();

		// cache output
		renderAxis = tweenAngles.ToMat3();
		lastReturnedAngles = tweenAngles;
		lastReturnedAngVelocity = tweenAngVelocity;
		lastReturnedAngAcceleration = tweenAngAcceleration;

		//
		// Debugging info
		//
#ifdef PREDICTION_ERROR_DECAY_DEBUG
		if ( debugFile != NULL ) {
			if ( owner != NULL ) {
				debugFile->Printf( "%i,", owner->entityNumber );
			} else {
				debugFile->Printf( "-1," );
			}

			// timing
			debugFile->Printf( "%i,%i,%i,%i,", gameLocal.time, networkTime, networkPacketDelay, timeSinceNewPacket );

			// angles
			idAngles renderAngles = renderAxis.ToAngles();
			debugFile->Printf( "%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,", networkAngles.pitch, networkAngles.yaw, networkAngles.roll,
																predictedAngles.pitch, predictedAngles.yaw, predictedAngles.roll );
			debugFile->Printf( "%.2f,%.2f,%.2f,", renderAngles.pitch, renderAngles.yaw, renderAngles.roll );
			debugFile->Printf( "\n" );
		}
#endif
	} else {
		// do nothing - it hasn't calibrated itself appropriately yet
		lastReturnedAngles = renderAxis.ToAngles();
	}

	lastDecayTime = gameLocal.time;

	// gracefully handle bad values
	// TWTODO: Proper fix!
	if ( MAT_CHECK_BAD( renderAxis ) ) {
		gameLocal.Warning( "sdPredictionErrorDecay_Angles::Decay - Bad float!" );
		assert( false );
		renderAxis = predictedAxes;
		Reset( renderAxis );
	}
}

/*
===============
sdPredictionErrorDecay_Angles::OnNewInfo
===============
*/
void sdPredictionErrorDecay_Angles::OnNewInfo( const idMat3& serverAxes ) {
	assert( owner );

	if ( !net_predictionErrorDecay.GetBool() ) {
		return;
	}

	int newDelay = gameLocal.time - networkTime;

	if ( newDelay < owner->aorPacketSpread ) {
		if ( owner->IsPhysicsInhibited() ) {
			networkAngles = serverAxes.ToAngles();
			networkTime = gameLocal.time;
			FixAngles();
		}
		return;
	}

	// see if it falls beneath the interesting threshold
	idAngles serverAngles = serverAxes.ToAngles();
	idAngles diffAngles = networkAngles - serverAngles;
	diffAngles.Normalize180();
	idVec3 diffAnglesVec( diffAngles[ 0 ], diffAngles[ 1 ], diffAngles[ 2 ] );
	float diffSqr = diffAnglesVec.LengthSqr();
	if ( diffSqr < Square( 0.05f ) ) {
		if ( diffSqr < idMath::FLT_EPSILON && gameLocal.time > lastDuplicateTime ) {
			// its basically identical to the last angles!
			numDuplicates++;
			lastDuplicateTime = gameLocal.time;
			if ( numDuplicates >= 2 ) {
				// 2 duplicates - we must be stationary
				isStationary = true;
			}
		}
		networkAngles = serverAngles;
		networkTime = gameLocal.time;
		FixAngles();
		return;
	}

	if ( isStationary ) {
		newDelay = owner->aorPacketSpread;
		isStationary = false;
		numDuplicates = 0;
	}

	if ( newDelay > 0 ) {
//		networkPacketDelay = ( newDelay + networkPacketDelay ) * 0.5f;
		networkPacketDelay = newDelay;
	}

	// don't let the delay get too big
	if ( networkPacketDelay > 1000 ) {
		networkPacketDelay = 1000;
	}

	if ( isNew ) {
		networkPacketDelay = 0;
		isNew = false;

		networkTime = gameLocal.time;
		networkAngles = serverAxes.ToAngles();

		lastNetworkTime = networkTime;
		lastNetworkAngles = networkAngles;

		lastLastNetworkTime = lastNetworkTime;
		lastLastNetworkAngles = lastNetworkAngles;

	} else {

		lastLastNetworkTime = lastNetworkTime;
		lastLastNetworkAngles = lastNetworkAngles;

		lastNetworkTime = networkTime;
		lastNetworkAngles = networkAngles;

		networkTime = gameLocal.time;
		networkAngles = serverAxes.ToAngles();

		FixAngles();
	}
}

/*
===============
sdPredictionErrorDecay_Angles::FixAngles
===============
*/
void sdPredictionErrorDecay_Angles::FixAngles( void ) {
	lastNetworkAngles = networkAngles - ( networkAngles - lastNetworkAngles ).Normalize180();
	lastLastNetworkAngles = lastNetworkAngles - ( lastNetworkAngles - lastLastNetworkAngles ).Normalize180();
	lastReturnedAngles = lastNetworkAngles - ( lastNetworkAngles - lastReturnedAngles ).Normalize180();
}

/*
===============
sdPredictionErrorDecay_Angles::NeedsUpdate
===============
*/
bool sdPredictionErrorDecay_Angles::NeedsUpdate( void ) {
	return gameLocal.time >= lastDecayTime && !IsNew() && ( ( gameLocal.time - networkTime ) < SEC2MS( MAX_PREDICTION_TIME_OFFSET ) );
}