csgo-2018-source/game/client/prediction.cpp

//========= Copyright  1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "prediction.h"
#include "igamemovement.h"
#include "prediction_private.h"
#include "ivrenderview.h"
#include "iinput.h"
#include "usercmd.h"
#include <vgui_controls/Controls.h>
#include <vgui/ISurface.h>
#include <vgui/IScheme.h>
#include "hud.h"
#include "iclientvehicle.h"
#include "in_buttons.h"
#include "con_nprint.h"
#include "hud_pdump.h"
#include "datacache/imdlcache.h"

#ifdef HL2_CLIENT_DLL
#include "c_basehlplayer.h"
#endif

#ifdef PORTAL2
#include "c_portal_player.h"
#endif

#include "tier0/vprof.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

IPredictionSystem *IPredictionSystem::g_pPredictionSystems = NULL;

#if !defined( NO_ENTITY_PREDICTION )

extern ConVar cl_predictphysics;

ConVar	cl_predictweapons	( "cl_predictweapons","1", FCVAR_USERINFO | FCVAR_NOT_CONNECTED, "Perform client side prediction of weapon effects." );
ConVar	cl_lagcompensation	( "cl_lagcompensation","1", FCVAR_USERINFO | FCVAR_NOT_CONNECTED, "Perform server side lag compensation of weapon firing events." );
ConVar	cl_showerror		( "cl_showerror", "0", FCVAR_RELEASE, "Show prediction errors, 2 for above plus detailed field deltas." );

static ConVar	cl_idealpitchscale	( "cl_idealpitchscale", "0.8", FCVAR_ARCHIVE );
static ConVar	cl_predictionlist	( "cl_predictionlist", "0", FCVAR_CHEAT, "Show which entities are predicting\n" );

static ConVar	cl_predictionentitydump( "cl_pdump", "-1", FCVAR_CHEAT, "Dump info about this entity to screen." );
static ConVar	cl_predictionentitydumpbyclass( "cl_pclass", "", FCVAR_CHEAT, "Dump entity by prediction classname." );
static ConVar	cl_pred_optimize( "cl_pred_optimize", "2", 0, "Optimize for not copying data if didn't receive a network update (1), and also for not repredicting if there were no errors (2)." );

static ConVar	cl_pred_doresetlatch( "cl_pred_doresetlatch", "1", 0 );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void InvalidateEFlagsRecursive( C_BaseEntity *pEnt, int nDirtyFlags, int nChildFlags = 0 )
{
	pEnt->AddEFlags( nDirtyFlags );
	nDirtyFlags |= nChildFlags;
	for (CBaseEntity *pChild = pEnt->FirstMoveChild(); pChild; pChild = pChild->NextMovePeer())
	{
		InvalidateEFlagsRecursive( pChild, nDirtyFlags );
	}
}

#endif

extern IGameMovement *g_pGameMovement;
extern CMoveData *g_pMoveData;

void COM_Log( const char *pszFile, PRINTF_FORMAT_STRING const char *fmt, ...) FMTFUNCTION( 2, 3 ); // Log a debug message to specified file ( if pszFile == NULL uses c:\\hllog.txt )
void PhysicsSimulate( void );

#if defined( PORTAL )
ConVar cl_predicted_movement_uses_uninterpolated_physics( "cl_predicted_movement_uses_uninterpolated_physics", "1" );
extern void MoveUnpredictedPhysicsNearPlayerToNetworkedPosition( CBasePlayer *pPlayer );
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CPrediction::CPrediction( void ) : m_SavedVars( true )
{
#if !defined( NO_ENTITY_PREDICTION )
	m_bInPrediction = false;

	m_nPreviousStartFrame = -1;
	m_nIncomingPacketNumber = 0;

	m_bPlayerOriginTypedescriptionSearched = false;
	m_bEnginePaused = false;
	m_pPDumpPanel = NULL;

	m_flLastServerWorldTimeStamp = -1.0f;
#endif
}

CPrediction::~CPrediction( void )
{
}

void CPrediction::Init( void )
{
#if !defined( NO_ENTITY_PREDICTION )
	m_bOldCLPredictValue = cl_predict->GetBool();
	m_pPDumpPanel = GetPDumpPanel();
#endif
}

void CPrediction::Shutdown( void )
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------

void CPrediction::CheckError( int nSlot, C_BasePlayer *player, int commands_acknowledged )
{
#if !defined( NO_ENTITY_PREDICTION )
	Vector		origin;
	Vector		delta;
	float		len;
	static int	pos[ MAX_SPLITSCREEN_PLAYERS ];

	// Not in the game yet
	if ( !engine->IsInGame() )
		return;

	// Not running prediction
	if ( !cl_predict->GetInt() )
		return;

	if ( !player )
		return;
	
	// Not predictable yet (flush entity packet?)
	if ( !player->IsIntermediateDataAllocated() )
		return;

	origin = player->GetNetworkOrigin();
		
	const void *slot = player->GetPredictedFrame( commands_acknowledged - 1 );
	if ( !slot )
		return;

	if ( !m_bPlayerOriginTypedescriptionSearched )
	{
		m_bPlayerOriginTypedescriptionSearched = true;
#ifndef PREDICT_ORIGIN_SPLIT
		const typedescription_t *td = CPredictionCopy::FindFlatFieldByName( "m_vecNetworkOrigin", player->GetPredDescMap() );
		if ( td ) 
		{
			m_PlayerOriginTypeDescription.AddToTail( td );
		}
#else
		const typedescription_t *td = CPredictionCopy::FindFlatFieldByName( "m_vecNetworkOrigin.x", player->GetPredDescMap() );
		if ( td )
		{
			m_PlayerOriginTypeDescription.AddToTail( td );
		}
		td = CPredictionCopy::FindFlatFieldByName( "m_vecNetworkOrigin.y", player->GetPredDescMap() );
		if ( td )
		{
			m_PlayerOriginTypeDescription.AddToTail( td );
		}
		td = CPredictionCopy::FindFlatFieldByName( "m_vecNetworkOrigin.z", player->GetPredDescMap() );
		if ( td )
		{
			m_PlayerOriginTypeDescription.AddToTail( td );
		}

		if( m_PlayerOriginTypeDescription.Count() != 3 )
		{
			m_PlayerOriginTypeDescription.RemoveAll();
			return;
		}
#endif
	}

	if ( !m_PlayerOriginTypeDescription.Count() )
		return;

	Vector predicted_origin;

	// Find the origin field in the database
	// Splitting m_vecNetworkOrigin into component fields for prediction *
#ifndef PREDICT_ORIGIN_SPLIT
	Q_memcpy( (Vector *)&predicted_origin, (Vector *)( (byte *)slot + m_PlayerOriginTypeDescription[ 0 ]->flatOffset[ TD_OFFSET_PACKED ] ), sizeof( Vector ) );
#else
	for ( int i = 0; i < 3; ++i )
	{
		Q_memcpy( (float *)&predicted_origin[ i ], (float *)( (byte *)slot + m_PlayerOriginTypeDescription[ i ]->flatOffset[ TD_OFFSET_PACKED ] ), sizeof( float ) );
	}
#endif

	// Compare what the server returned with what we had predicted it to be
	VectorSubtract ( predicted_origin, origin, delta );

	len = VectorLength( delta );
	if (len > MAX_PREDICTION_ERROR )
	{	
		// A teleport or something, clear out error
		len = 0;
	}
	else
	{
		if ( len > MIN_PREDICTION_EPSILON )
		{
			player->NotePredictionError( delta );

			if ( cl_showerror.GetInt() >= 1 )
			{
				con_nprint_t np;
				np.fixed_width_font = true;
				np.color[0] = 1.0f;
				np.color[1] = 0.95f;
				np.color[2] = 0.7f;
				np.index = 4 + nSlot * 10 + ( ++pos[ nSlot ] % 10 );
				np.time_to_live = 3.0f;

				engine->Con_NXPrintf( &np, "%d len(%6.3f) (%6.3f %6.3f %6.3f)", nSlot, len, delta.x, delta.y, delta.z );
			}
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPrediction::ShutdownPredictables( void )
{
#if !defined( NO_ENTITY_PREDICTION )

	int shutdown_count = 0;
	int release_count = 0;

	for ( int nSlot = 0; nSlot < MAX_SPLITSCREEN_PLAYERS; ++nSlot )
	{
		// Transfer intermediate data from other predictables
		int c = GetPredictables( nSlot )->GetPredictableCount();
		for ( int i = c - 1; i >= 0 ; i-- )
		{
			C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
			if ( !ent )
				continue;

			// Shutdown predictables
			if ( ent->GetPredictable() )
			{
				ent->ShutdownPredictable();
				shutdown_count++;
			}
			// Otherwise, release client created entities
			else
			{
				ent->Release();
				release_count++;
			}
		}

		// All gone now...
		Assert( GetPredictables( nSlot )->GetPredictableCount() == 0 );
	}

	if ( ( release_count > 0 ) || 
		 ( shutdown_count > 0 ) )
	{
		DevMsg( "Shutdown %i predictable entities and %i client-created entities\n",
			shutdown_count,
			release_count );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPrediction::ReinitPredictables( void )
{
#if !defined( NO_ENTITY_PREDICTION )
	// Go through all entities and init any eligible ones
	int i;
	int c = ClientEntityList().GetHighestEntityIndex();
	for ( i = 0; i <= c; i++ )
	{
		C_BaseEntity *e = ClientEntityList().GetBaseEntity( i );
		if ( !e )
			continue;
		
		if ( e->GetPredictable() )
			continue;

		e->CheckInitPredictable( "ReinitPredictables" );
	}

	FOR_EACH_VALID_SPLITSCREEN_PLAYER( nSlot )
	{
		Msg( "%d:  Reinitialized %i predictable entities\n",
			nSlot, GetPredictables( nSlot )->GetPredictableCount() );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPrediction::OnReceivedUncompressedPacket( void )
{
#if !defined( NO_ENTITY_PREDICTION )
	m_nPreviousStartFrame = -1;
	for ( int i = 0 ; i < MAX_SPLITSCREEN_PLAYERS; ++i )
	{
		Split_t &split = m_Split[ i ];
		split.m_nCommandsPredicted = 0;
		split.m_nServerCommandsAcknowledged = 0;
		split.m_nLastCommandAcknowledged = 0;
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : commands_acknowledged - 
//			current_world_update_packet - 
// Output : void CPrediction::PreEntityPacketReceived
//-----------------------------------------------------------------------------
void CPrediction::PreEntityPacketReceived ( int commands_acknowledged, int current_world_update_packet, int server_ticks_elapsed )
{
#if !defined( NO_ENTITY_PREDICTION )
#if defined( _DEBUG )
	char sz[ 32 ];
	Q_snprintf( sz, sizeof( sz ), "preentitypacket%d", commands_acknowledged );
	PREDICTION_TRACKVALUECHANGESCOPE( sz );
#endif
	VPROF( "CPrediction::PreEntityPacketReceived" );

	// Cache off incoming packet #
	m_nIncomingPacketNumber = current_world_update_packet;
	C_BaseEntity::s_nIncomingPacketCommandsAcknowledged = commands_acknowledged;

	// Don't screw up memory of current player from history buffers if not filling in history buffers
	//  during prediction!!!
	if ( !cl_predict->GetInt() )
	{
		ShutdownPredictables();
		return;
	}

	FOR_EACH_VALID_SPLITSCREEN_PLAYER( nSlot )
	{
		C_BasePlayer *current = C_BasePlayer::GetLocalPlayer( nSlot );
		// No local player object?
		if ( !current )
			continue;

		// Transfer intermediate data from other predictables
		int c = GetPredictables( nSlot )->GetPredictableCount();

		int i;
		for ( i = 0; i < c; i++ )
		{
			C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
			if ( !ent )
				continue;

			if ( !ent->GetPredictable() )
				continue;

			if ( (commands_acknowledged != server_ticks_elapsed) && ent->PredictionIsPhysicallySimulated() )
			{
				ent->ShiftIntermediateData_TickAdjust( server_ticks_elapsed - commands_acknowledged, m_Split[nSlot].m_nCommandsPredicted );
				m_Split[nSlot].m_bPerformedTickShift = true;
			}

			ent->PreEntityPacketReceived( commands_acknowledged );
			ent->OnPostRestoreData();
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Called for every packet received( could be multiple times per frame)
//-----------------------------------------------------------------------------
void CPrediction::PostEntityPacketReceived( void )
{
#if !defined( NO_ENTITY_PREDICTION )
	PREDICTION_TRACKVALUECHANGESCOPE( "postentitypacket" );
	VPROF( "CPrediction::PostEntityPacketReceived" );

	C_BaseEntity::s_nIncomingPacketCommandsAcknowledged = -1;

	// Don't screw up memory of current player from history buffers if not filling in history buffers
	//  during prediction!!!
	if ( !cl_predict->GetInt() )
		return;

	FOR_EACH_VALID_SPLITSCREEN_PLAYER( nSlot )
	{
		C_BasePlayer *current = C_BasePlayer::GetLocalPlayer( nSlot );
		// No local player object?
		if ( !current )
			continue;

		int c = GetPredictables( nSlot )->GetPredictableCount();

		// Transfer intermediate data from other predictables
		int i;
		for ( i = 0; i < c; i++ )
		{
			C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
			if ( !ent )
				continue;

			if ( !ent->GetPredictable() )
				continue;

			// Always mark as changed
			if ( AddDataChangeEvent( ent, DATA_UPDATE_DATATABLE_CHANGED, &ent->m_DataChangeEventRef ) )
			{
				ent->OnPreDataChanged( DATA_UPDATE_DATATABLE_CHANGED );
			}
			ent->PostEntityPacketReceived();
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *ent - 
// Output : static bool
//-----------------------------------------------------------------------------
bool CPrediction::ShouldDumpEntity( C_BaseEntity *ent )
{
#if !defined( NO_ENTITY_PREDICTION )
	int dump_entity = cl_predictionentitydump.GetInt();
	if ( dump_entity != -1 )
	{
		bool dump = false;
		if ( ent->entindex() == -1 )
		{
			dump = ( dump_entity == ent->entindex() ) ? true : false;
		}
		else
		{
			dump = ( ent->entindex() == dump_entity ) ? true : false;
		}

		if ( !dump )
		{
			return false;
		}
	}
	else
	{
		if ( cl_predictionentitydumpbyclass.GetString()[ 0 ] == 0 )
			return false;

		if ( !FClassnameIs( ent, cl_predictionentitydumpbyclass.GetString() ) )
			return false;
	}
	return true;
#else
	return false;
#endif
}

void CPrediction::ShowPredictionListEntry( int listRow, int showlist, C_BaseEntity *ent, int &totalsize, int &totalsize_intermediate )
{
	char sz[ 32 ];
	if ( ent->entindex() == -1 )
	{
		Q_snprintf( sz, sizeof( sz ), "handle %u", (unsigned int)ent->GetClientHandle().ToInt() );
	}
	else
	{
		Q_snprintf( sz, sizeof( sz ), "%i", ent->entindex() );
	}

	int oIndex = 0;
	if ( ent->GetOwnerEntity() )
	{
		oIndex = ent->GetOwnerEntity()->entindex();
	}
	else if ( ent->IsPlayer() )
	{
		oIndex = ent->entindex();
	}
	else 
	{
		C_BaseViewModel *pVM = ToBaseViewModel( ent );
		if ( pVM && pVM->GetOwner() )
		{
			oIndex = pVM->GetOwner()->entindex();
		}
	}

	con_nprint_t np;
	np.fixed_width_font = true;
	np.color[0] = 0.8f;
	np.color[1] = 1.0f;
	np.color[2] = 1.0f;
	np.time_to_live = 2.0f;
	np.index = listRow;
	if ( showlist >= 2 )
	{
		int size = GetClassMap().GetClassSize( ent->GetClassname() );
		int intermediate_size = ent->GetIntermediateDataSize() * ( MULTIPLAYER_BACKUP + 1 );

		engine->Con_NXPrintf( &np, "%15s %30s(%d) (%5i / %5i bytes): %15s", 
			sz, 
			ent->GetClassname(),
			oIndex,
			size,
			intermediate_size,
			ent->GetPredictable() ? "predicted" : "client created" );

		totalsize += size;
		totalsize_intermediate += intermediate_size;
	}
	else
	{
		engine->Con_NXPrintf( &np, "%15s %30s(%d): %15s", 
			sz, 
			ent->GetClassname(),
			oIndex,
			ent->GetPredictable() ? "predicted" : "client created" );
	}
}

void CPrediction::FinishPredictionList( int listRow, int showlist, int totalsize, int totalsize_intermediate )
{
	if ( !showlist )
		return;

	if ( showlist > 1 )
	{
		con_nprint_t np;
		np.fixed_width_font = true;
		np.color[0] = 0.8f;
		np.color[1] = 1.0f;
		np.color[2] = 1.0f;
		np.time_to_live = 2.0f;
		np.index = listRow++;
		char sz1[32];
		char sz2[32];

		Q_strncpy( sz1, Q_pretifymem( (float)totalsize ), sizeof( sz1 ) );
		Q_strncpy( sz2, Q_pretifymem( (float)totalsize_intermediate ), sizeof( sz2 ) );

		engine->Con_NXPrintf( &np, "%15s %27s (%s / %s)  %14s", 
			"totals:", 
			"",
			sz1,
			sz2,
			"" );
	}

	// Zero out rest of list
	while ( listRow < 20 )
	{
		engine->Con_NPrintf( listRow++, "" );
	}
}

void CPrediction::CheckPredictConvar()
{
	if ( cl_predict->GetBool() != m_bOldCLPredictValue )
	{
		if ( !m_bOldCLPredictValue )
		{
			ReinitPredictables();
		}

		for ( int i = 0 ; i < MAX_SPLITSCREEN_PLAYERS; ++i )
		{
			Split_t &split = m_Split[ i ];
			split.m_nCommandsPredicted = 0;
			split.m_nServerCommandsAcknowledged = 0;
			split.m_nLastCommandAcknowledged = 0;
		}
		m_nPreviousStartFrame = -1;
	}

	m_bOldCLPredictValue = cl_predict->GetBool();
}

ConVar cl_prediction_error_timestamps( "cl_prediction_error_timestamps", "0" );
//-----------------------------------------------------------------------------
// Purpose: Called at the end of the frame if any packets were received
// Input  : error_check - 
//			last_predicted - 
//-----------------------------------------------------------------------------
void CPrediction::PostNetworkDataReceived( int commands_acknowledged )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::PostNetworkDataReceived" );

	bool error_check = ( commands_acknowledged > 0 ) ? true : false;
#if defined( _DEBUG )
	char sz[ 32 ];
	Q_snprintf( sz, sizeof( sz ), "postnetworkdata%d", commands_acknowledged );
	PREDICTION_TRACKVALUECHANGESCOPE( sz );
#endif
	//Msg( "%i/%i ack %i commands/slot\n",
	//	gpGlobals->framecount,
	//	gpGlobals->tickcount,
	//	commands_acknowledged - 1 );

	bool entityDumped = false;
	bool bPredict = cl_predict->GetBool();
	int showlist = cl_predictionlist.GetInt();

	int listRow = 0;

	FOR_EACH_VALID_SPLITSCREEN_PLAYER( nSlot )
	{
		Split_t &split = m_Split[ nSlot ];
		split.m_nServerCommandsAcknowledged += commands_acknowledged;
		split.m_bPreviousAckHadErrors = false;
		split.m_bPreviousAckErrorTriggersFullLatchReset = false;
		split.m_EntsWithPredictionErrorsInLastAck.RemoveAll();

		if ( bPredict )
		{
			// Don't screw up memory of current player from history buffers if not filling in history buffers during prediction!!!
			int totalsize = 0;
			int totalsize_intermediate = 0;

			// Build list of all predictables
			int c = GetPredictables( nSlot )->GetPredictableCount();
			bool *bHadErrors = (bool *)stackalloc( sizeof( bool ) * c );
			// Transfer intermediate data from other predictables
			int i;
			for ( i = 0; i < c; i++ )
			{
				C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
				if ( !ent )
					continue;

				if ( !ent->GetPredictable() )
					continue;

				bHadErrors[i] = ent->PostNetworkDataReceived( split.m_nServerCommandsAcknowledged );
				if ( bHadErrors[i] )
				{
					split.m_bPreviousAckHadErrors = true;
					split.m_bPreviousAckErrorTriggersFullLatchReset |= ent->PredictionErrorShouldResetLatchedForAllPredictables();
					split.m_EntsWithPredictionErrorsInLastAck.AddToTail( ent ); 
				}

				if ( !showlist )
				{
					if ( error_check && 
						!entityDumped &&
						m_pPDumpPanel &&
						ShouldDumpEntity( ent ) )
					{
						entityDumped = true;
						m_pPDumpPanel->DumpEntity( ent, split.m_nServerCommandsAcknowledged );
					}
					continue;
				}

				ShowPredictionListEntry( listRow, showlist, ent, totalsize, totalsize_intermediate );
				listRow++;
			}

			//Give entities with predicted fields that are not networked a chance to fix their current values for those fields.
			//We do this in two passes. One pass to fix the fields, then another to save off the changes after they've all finished (to handle interdependancies, portals)
			if( split.m_bPreviousAckHadErrors )
			{
				//give each predicted entity a chance to fix up its non-networked predicted fields
				for ( i = 0; i < c; i++ )
				{
					C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
					if ( !ent )
						continue;

					if ( !ent->GetPredictable() )
						continue;

					ent->HandlePredictionError( bHadErrors[i] );
				}

				//save off any changes
				for ( i = 0; i < c; i++ )
				{
					C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
					if ( !ent )
						continue;

					if ( !ent->GetPredictable() )
						continue;

					ent->SaveData( "PostNetworkDataReceived() Ack Errors", C_BaseEntity::SLOT_ORIGINALDATA, PC_EVERYTHING );
				}
			}

			for ( i = c; --i >= 0; ) //go backwards to maintain ordering on shutdown
			{
				C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
				if ( !ent )
					continue;

				if ( !ent->GetPredictable() )
					continue;

				ent->CheckShutdownPredictable( "CPrediction::PostNetworkDataReceived" );
			}

			FinishPredictionList( listRow, showlist, totalsize, totalsize_intermediate );

			if ( error_check )
			{
				C_BasePlayer *current = C_BasePlayer::GetLocalPlayer( nSlot );
				if ( !current )
					continue;
				CheckError( nSlot, current, split.m_nServerCommandsAcknowledged );
			}
		}

		// Can also look at regular entities
		int dumpentindex = cl_predictionentitydump.GetInt();
		if ( m_pPDumpPanel && error_check && !entityDumped && dumpentindex != -1 )
		{
			int last_entity = ClientEntityList().GetHighestEntityIndex();
			if ( dumpentindex >= 0 && dumpentindex <= last_entity )
			{
				C_BaseEntity *ent = ClientEntityList().GetBaseEntity( dumpentindex );
				if ( ent )
				{
					m_pPDumpPanel->DumpEntity( ent, split.m_nServerCommandsAcknowledged );
					entityDumped = true;
				}
			}
		}

		if( split.m_bPreviousAckHadErrors && cl_prediction_error_timestamps.GetBool() )
		{
			Warning( "Prediction errors occurred at %i %f\n", gpGlobals->tickcount, gpGlobals->curtime );
		}
	}

	CheckPredictConvar();

	if ( m_pPDumpPanel && error_check && !entityDumped )
	{
		m_pPDumpPanel->Clear();
	}
#endif

}

//-----------------------------------------------------------------------------
// Purpose: Prepare for running prediction code
// Input  : *ucmd - 
//			*from - 
//			*pHelper - 
//			&moveInput - 
//-----------------------------------------------------------------------------
void CPrediction::SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move ) 
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::SetupMove" );

	move->m_bFirstRunOfFunctions = IsFirstTimePredicted();
	move->m_bGameCodeMovedPlayer = false;
	if ( player->GetPreviouslyPredictedOrigin() != player->GetNetworkOrigin() )
	{
		move->m_bGameCodeMovedPlayer = true;
	}
	
	move->m_nPlayerHandle = player->GetClientHandle();
	move->m_vecVelocity		= player->GetAbsVelocity();
	move->SetAbsOrigin( player->GetNetworkOrigin() );
	move->m_vecOldAngles	= move->m_vecAngles;
	move->m_nOldButtons		= player->m_Local.m_nOldButtons;
	move->m_flClientMaxSpeed = player->m_flMaxspeed;

	move->m_vecAngles		= ucmd->viewangles;
	move->m_vecViewAngles	= ucmd->viewangles;
	move->m_nImpulseCommand = ucmd->impulse;	
	move->m_nButtons		= ucmd->buttons;

	CBaseEntity *pMoveParent = player->GetMoveParent();
	if (!pMoveParent)
	{
		move->m_vecAbsViewAngles = move->m_vecViewAngles;
	}
	else
	{
		matrix3x4_t viewToParent, viewToWorld;
		AngleMatrix( move->m_vecViewAngles, viewToParent );
		ConcatTransforms( pMoveParent->EntityToWorldTransform(), viewToParent, viewToWorld );
		MatrixAngles( viewToWorld, move->m_vecAbsViewAngles );
	}


	// Ingore buttons for movement if at controls
	if (player->GetFlags() & FL_ATCONTROLS)
	{
		move->m_flForwardMove		= 0;
		move->m_flSideMove			= 0;
		move->m_flUpMove			= 0;
	}
	else
	{
		move->m_flForwardMove		= ucmd->forwardmove;
		move->m_flSideMove			= ucmd->sidemove;
		move->m_flUpMove			= ucmd->upmove;
	}
		
	IClientVehicle *pVehicle = player->GetVehicle();
	if (pVehicle)
	{
		pVehicle->SetupMove( player, ucmd, pHelper, move ); 
	}

	// Copy constraint information
	if ( player->m_hConstraintEntity )
		move->m_vecConstraintCenter = player->m_hConstraintEntity->GetAbsOrigin();
	else
		move->m_vecConstraintCenter = player->m_vecConstraintCenter;

	move->m_flConstraintRadius = player->m_flConstraintRadius;
	move->m_flConstraintWidth = player->m_flConstraintWidth;
	move->m_flConstraintSpeedFactor = player->m_flConstraintSpeedFactor;

#ifdef HL2_CLIENT_DLL
	// Convert to HL2 data.
	C_BaseHLPlayer *pHLPlayer = static_cast<C_BaseHLPlayer*>( player );
	Assert( pHLPlayer );

	CHLMoveData *pHLMove = static_cast<CHLMoveData*>( move );
	Assert( pHLMove );

	pHLMove->m_bIsSprinting = pHLPlayer->IsSprinting();
#endif
	
	g_pGameMovement->SetupMovementBounds( move );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Finish running prediction code
// Input  : &move - 
//			*to - 
//-----------------------------------------------------------------------------
void CPrediction::FinishMove( C_BasePlayer *player, CUserCmd *ucmd, CMoveData *move )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::FinishMove" );

	player->m_RefEHandle = move->m_nPlayerHandle;

	player->SetAbsVelocity( move->m_vecVelocity );

	player->m_vecNetworkOrigin = move->GetAbsOrigin();
	player->SetPreviouslyPredictedOrigin( move->GetAbsOrigin() );
	
	player->m_Local.m_nOldButtons = move->m_nButtons;


	player->m_flMaxspeed = move->m_flClientMaxSpeed;
	
	m_hLastGround = player->GetGroundEntity();
 
	player->SetLocalOrigin( move->GetAbsOrigin() );

	IClientVehicle *pVehicle = player->GetVehicle();
	if (pVehicle)
	{
		pVehicle->FinishMove( player, ucmd, move ); 
	}

	// Sanity checks
	if ( player->m_hConstraintEntity )
		Assert( move->m_vecConstraintCenter == player->m_hConstraintEntity->GetAbsOrigin() );
	else
		Assert( move->m_vecConstraintCenter == player->m_vecConstraintCenter );
	Assert( move->m_flConstraintRadius == player->m_flConstraintRadius );
	Assert( move->m_flConstraintWidth == player->m_flConstraintWidth );
	Assert( move->m_flConstraintSpeedFactor == player->m_flConstraintSpeedFactor );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Called before any movement processing
// Input  : *player - 
//			*cmd - 
//-----------------------------------------------------------------------------
void CPrediction::StartCommand( C_BasePlayer *player, CUserCmd *cmd )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::StartCommand" );

#if defined( USE_PREDICTABLEID )
	CPredictableId::ResetInstanceCounters();
#endif

	player->m_pCurrentCommand = cmd;
	player->m_LastCmd = *cmd;
	C_BaseEntity::SetPredictionRandomSeed( cmd );
	C_BaseEntity::SetPredictionPlayer( player );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Called after any movement processing
// Input  : *player - 
//-----------------------------------------------------------------------------
void CPrediction::FinishCommand( C_BasePlayer *player )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::FinishCommand" );

	player->m_pCurrentCommand = NULL;
	C_BaseEntity::SetPredictionRandomSeed( NULL );
	C_BaseEntity::SetPredictionPlayer( NULL );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Called before player thinks
// Input  : *player - 
//			thinktime - 
//-----------------------------------------------------------------------------
void CPrediction::RunPreThink( C_BasePlayer *player )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RunPreThink" );

	// Run think functions on the player
	if ( !player->PhysicsRunThink() )
		return;

	// Called every frame to let game rules do any specific think logic for the player
	// FIXME:  Do we need to set up a client side version of the gamerules???
	// g_pGameRules->PlayerThink( player );

	player->PreThink();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Runs the PLAYER's thinking code if time.  There is some play in the exact time the think
//  function will be called, because it is called before any movement is done
//  in a frame.  Not used for pushmove objects, because they must be exact.
//  Returns false if the entity removed itself.
// Input  : *ent - 
//			frametime - 
//			clienttimebase - 
// Output : void CPlayerMove::RunThink
//-----------------------------------------------------------------------------
void CPrediction::RunThink (C_BasePlayer *player, double frametime )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RunThink" );

	int thinktick = player->GetNextThinkTick();

	if ( thinktick <= 0 || thinktick > player->m_nTickBase )
		return;
	
	player->SetNextThink( TICK_NEVER_THINK );

	// Think
	player->Think();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Called after player movement
// Input  : *player - 
//			thinktime - 
//			frametime - 
//-----------------------------------------------------------------------------
void CPrediction::RunPostThink( C_BasePlayer *player )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RunPostThink" );

	// Run post-think
	player->PostThink();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Checks if the player is standing on a moving entity and adjusts velocity and 
//  basevelocity appropriately
// Input  : *player - 
//			frametime - 
//-----------------------------------------------------------------------------
void CPrediction::CheckMovingGround( C_BasePlayer *player, double frametime )
{
	CBaseEntity	    *groundentity;

	if ( player->GetFlags() & FL_ONGROUND )
	{
		groundentity = player->GetGroundEntity();
		if ( groundentity && ( groundentity->GetFlags() & FL_CONVEYOR) )
		{
			Vector vecNewVelocity;
			groundentity->GetGroundVelocityToApply( vecNewVelocity );
			if ( player->GetFlags() & FL_BASEVELOCITY )
			{
				vecNewVelocity += player->GetBaseVelocity();
			}
			player->SetBaseVelocity( vecNewVelocity );
			player->AddFlag( FL_BASEVELOCITY );
		}
	}

	if ( !( player->GetFlags() & FL_BASEVELOCITY ) )
	{
		// Apply momentum (add in half of the previous frame of velocity first)
		player->ApplyAbsVelocityImpulse( (1.0 + ( frametime * 0.5 )) * player->GetBaseVelocity() );
		player->SetBaseVelocity( vec3_origin );
	}

	player->RemoveFlag( FL_BASEVELOCITY );
}

//-----------------------------------------------------------------------------
// Purpose: Predicts a single movement command for player
// Input  : *moveHelper - 
//			*player - 
//			*u - 
//-----------------------------------------------------------------------------
void CPrediction::RunCommand( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *moveHelper )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RunCommand" );
#if defined( _DEBUG )
	char sz[ 32 ];
	Q_snprintf( sz, sizeof( sz ), "runcommand%04d", ucmd->command_number );
	PREDICTION_TRACKVALUECHANGESCOPE( sz );
#endif

#ifdef PORTAL2
	assert_cast<CPortal_Player*>( player )->PreventCrouchJump( ucmd );
#endif

	StartCommand( player, ucmd );

	// Set globals appropriately
	gpGlobals->curtime		= player->m_nTickBase * TICK_INTERVAL;
	gpGlobals->frametime	= m_bEnginePaused ? 0 : TICK_INTERVAL;

	// Add and subtract buttons we're forcing on the player
	ucmd->buttons |= player->m_afButtonForced;
	// ucmd->buttons &= ~player->m_afButtonDisabled; // MAY WANT TO DO THIS LATER!!!

	g_pGameMovement->StartTrackPredictionErrors( player );

// TODO
// TODO:  Check for impulse predicted?

	// Do weapon selection
	if ( ucmd->weaponselect != 0 )
	{
		C_BaseCombatWeapon *weapon = ToBaseCombatWeapon( CBaseEntity::Instance( ucmd->weaponselect ) );
		if ( weapon )
		{
			player->SelectItem( weapon->GetName(), ucmd->weaponsubtype );
		}
	}

	// Latch in impulse.
	IClientVehicle *pVehicle = player->GetVehicle();
	if ( ucmd->impulse )
	{
		// Discard impulse commands unless the vehicle allows them.
		// FIXME: UsingStandardWeapons seems like a bad filter for this. 
		// The flashlight is an impulse command, for example.
		if ( !pVehicle || player->UsingStandardWeaponsInVehicle() )
		{
			player->m_nImpulse = ucmd->impulse;
		}
	}

	// Get button states
	player->UpdateButtonState( ucmd->buttons );

// TODO
	CheckMovingGround( player, gpGlobals->frametime );

// TODO
//	g_pMoveData->m_vecOldAngles = player->pl.v_angle;

	// Copy from command to player unless game .dll has set angle using fixangle
	// if ( !player->pl.fixangle )
	{
		player->SetLocalViewAngles( ucmd->viewangles );
	}

	// Call standard client pre-think
	RunPreThink( player );

	// Call Think if one is set
	RunThink( player, TICK_INTERVAL );

	// Setup input.
	{
	
		SetupMove( player, ucmd, moveHelper, g_pMoveData );
	}


	{
		VPROF_BUDGET( "CPrediction::ProcessMovement", "CPrediction::ProcessMovement" );

		// RUN MOVEMENT
		if ( !pVehicle )
		{
			Assert( g_pGameMovement );
			g_pGameMovement->ProcessMovement( player, g_pMoveData );
		}
		else
		{
			pVehicle->ProcessMovement( player, g_pMoveData );
		}
	}

	FinishMove( player, ucmd, g_pMoveData );

	// Let server invoke any needed impact functions
	VPROF_SCOPE_BEGIN( "moveHelper->ProcessImpacts(cl)" );
	moveHelper->ProcessImpacts();
	VPROF_SCOPE_END();

	RunPostThink( player );

	g_pGameMovement->FinishTrackPredictionErrors( player );

	FinishCommand( player );
	g_pGameMovement->Reset();  // fixes a crash: when loading highlights twice or after previously loaded map, there was a dirty player pointer in game movement

	if( !m_bEnginePaused && gpGlobals->frametime > 0 )
	{
		player->m_nTickBase++;
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: In the forward direction, creates rays straight down and determines the
//  height of the 'floor' hit for each forward test.  Then, if the samples show that the
//  player is about to enter an up/down slope, sets *idealpitch to look up or down that slope
//  as appropriate
//-----------------------------------------------------------------------------
void CPrediction::SetIdealPitch ( int nSlot, C_BasePlayer *player, const Vector& origin, const QAngle& angles, const Vector& viewheight )
{
#if !defined( NO_ENTITY_PREDICTION )
	Vector	forward;
	Vector	top, bottom;
	float	floor_height[MAX_FORWARD];
	int		i, j;
	int		step, dir, steps;
	trace_t tr;

	if ( player->GetGroundEntity() == NULL )
		return;
	
	// Don't do this on the 360..
	if ( IsGameConsole() )
		return;

	AngleVectors( angles, &forward );
	forward[2] = 0;

	MDLCACHE_CRITICAL_SECTION();

	// Now move forward by 36, 48, 60, etc. units from the eye position and drop lines straight down
	//  160 or so units to see what's below
	for (i=0 ; i<MAX_FORWARD ; i++)
	{
		VectorMA( origin, (i+3)*12, forward, top );
		
		top[2] += viewheight[ 2 ];

		VectorCopy( top, bottom );

		bottom[2] -= 160;

		UTIL_TraceLine( top, bottom, MASK_SOLID, NULL, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );

		// looking at a wall, leave ideal the way it was
		if ( tr.allsolid )
			return;	

		// near a dropoff/ledge
		if ( tr.fraction == 1 )
			return;	
		
		floor_height[i] = top[2] + tr.fraction*( bottom[2] - top[2] );
	}
	
	dir = 0;
	steps = 0;
	for (j=1 ; j<i ; j++)
	{
		step = floor_height[j] - floor_height[j-1];
		if (step > -ON_EPSILON && step < ON_EPSILON)
			continue;

		if (dir && ( step-dir > ON_EPSILON || step-dir < -ON_EPSILON ) )
			return;		// mixed changes

		steps++;	
		dir = step;
	}
	
	Split_t &split = m_Split[ nSlot ];
	if (!dir)
	{
		split.m_flIdealPitch = 0;
		return;
	}
	
	if (steps < 2)
		return;
	split.m_flIdealPitch = -dir * cl_idealpitchscale.GetFloat();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Walk backward through predictables looking for ClientCreated entities
//  such as projectiles which were
// 1) not actually ack'd by the server or
// 2) were ack'd and made dormant and can now safely be removed
// Input  : last_command_packet - 
//-----------------------------------------------------------------------------
void CPrediction::RemoveStalePredictedEntities( int nSlot, int sequence_number )
{
#if !defined( NO_ENTITY_PREDICTION ) && defined( USE_PREDICTABLEID )
	VPROF( "CPrediction::RemoveStalePredictedEntities" );

	int oldest_allowable_command = sequence_number;

	// Walk backward due to deletion from UtlVector
	int c = GetPredictables( nSlot )->GetPredictableCount();
	int i;
	for ( i = c - 1; i >= 0; i-- )
	{
		C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
		if ( !ent )
			continue;

		// Don't do anything to truly predicted things (like player and weapons )
		if ( ent->GetPredictable() )
			continue;

		// What's left should be things like projectiles that are just waiting to be "linked"
		//  to their server counterpart and deleted
		Assert( ent->IsClientCreated() );
		if ( !ent->IsClientCreated() )
			continue;

		// Snag the PredictionContext
		PredictionContext *ctx = ent->m_pPredictionContext;
		if ( !ctx )
		{
			continue;
		}

		// If it was ack'd then the server sent us the entity.
		// Leave it unless it wasn't made dormant this frame, in
		//  which case it can be removed now
		if ( ent->m_PredictableID.GetAcknowledged() )
		{
			// Hasn't become dormant yet!!!
			if ( !ent->IsDormantPredictable() )
			{
				Assert( 0 );
				continue;
			}

			// Still gets to live till next frame
			if ( ent->BecameDormantThisPacket() )
				continue;

			C_BaseEntity *serverEntity = ctx->m_hServerEntity;
			if ( serverEntity )
			{
				// Notify that it's going to go away
				serverEntity->OnPredictedEntityRemove( true, ent );
			}
		}
		else
		{
			// Check context to see if it's too old?
			int command_entity_creation_happened = ctx->m_nCreationCommandNumber;
			// Give it more time to live...not time to kill it yet
			if ( command_entity_creation_happened > oldest_allowable_command )
				continue;

			// If the client predicted the KILLME flag it's possible
			//  that entity had such a short life that it actually
			//  never was sent to us.  In that case, just let it die a silent death
			if ( !ent->IsEFlagSet( EFL_KILLME ) )
			{
				if ( cl_showerror.GetInt() != 0 )
				{
					// It's bogus, server doesn't have a match, destroy it:
					Msg( "Removing unack'ed predicted entity:  %s created %s(%i) id == %s : %p\n",
						ent->GetClassname(),
						ctx->m_pszCreationModule,
						ctx->m_nCreationLineNumber,
						ent->m_PredictableID.Describe(),
						ent );
				}
			}

			// FIXME:  Do we need an OnPredictedEntityRemove call with an "it's not valid"
			// flag of some kind
		}

		// This will remove it from predictables list and will also free the entity, etc.
		ent->Release();
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPrediction::RestoreOriginalEntityState( int nSlot )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RestoreOriginalEntityState" );
	PREDICTION_TRACKVALUECHANGESCOPE( "restore" );

	Assert( C_BaseEntity::IsAbsRecomputationsEnabled() );

	// Transfer intermediate data from other predictables
	int c = GetPredictables( nSlot )->GetPredictableCount();
	for ( int i = 0; i < c; ++i )
	{
		C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
		if ( !ent || !ent->GetPredictable() )
			continue;

		ent->RestoreData( "RestoreOriginalEntityState", C_BaseEntity::SLOT_ORIGINALDATA, PC_EVERYTHING );
		ent->OnPostRestoreData();
	}
#endif
}

void CPrediction::ResetSimulationTick()
{
	ASSERT_LOCAL_PLAYER_RESOLVABLE();
	int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
	// Make sure simulation occurs at most once per entity per usercmd
	for (int  i = 0; i < GetPredictables( nSlot )->GetPredictableCount(); i++ )
	{
		C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );
		if ( entity && entity->GetSplitUserPlayerPredictionSlot() == nSlot )
		{
			entity->m_nSimulationTick = -1;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : current_command - 
//			curtime - 
//			*cmd - 
//			*tcmd - 
//			*localPlayer - 
//-----------------------------------------------------------------------------
void CPrediction::RunSimulation( int current_command, float curtime, CUserCmd *cmd, C_BasePlayer *localPlayer )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RunSimulation" );
	ASSERT_LOCAL_PLAYER_RESOLVABLE();
	int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT();

	Assert( localPlayer );
	C_CommandContext *ctx = localPlayer->GetCommandContext();
	Assert( ctx );
	
	ctx->needsprocessing = true;
	ctx->cmd = *cmd;
	ctx->command_number = current_command;

	IPredictionSystem::SuppressEvents( !IsFirstTimePredicted() );

	ResetSimulationTick();
	
	// Don't used cached numpredictables since entities can be created mid-prediction by the player
	for ( int i = 0; i < GetPredictables( nSlot )->GetPredictableCount(); i++ )
	{
		// Always reset
		gpGlobals->curtime		= curtime;
		gpGlobals->frametime	= m_bEnginePaused ? 0 : TICK_INTERVAL;

		C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );

		if ( !entity )
			continue;

		if ( entity->GetSplitUserPlayerPredictionSlot() != nSlot )
			continue;

		bool islocal = ( localPlayer == entity ) ? true : false;

		// Local player simulates first, if this assert fires then the predictables list isn't sorted 
		//  correctly (or we started predicting C_World???)
		if ( islocal && !IsValidSplitScreenSlot( i ) )
			continue;

		// Player can't be this so cull other entities here
		if ( entity->GetFlags() & FL_STATICPROP )
		{
			continue;
		}

		// Player is not actually in the m_SimulatedByThisPlayer list, of course
		if ( entity->IsPlayerSimulated() )
		{
			continue;
		}

		if ( AddDataChangeEvent( entity, DATA_UPDATE_DATATABLE_CHANGED, &entity->m_DataChangeEventRef ) )
		{
			entity->OnPreDataChanged( DATA_UPDATE_DATATABLE_CHANGED );
		}

		// Certain entities can be created locally and if so created, should be 
		//  simulated until a network update arrives
		if ( entity->IsClientCreated() )
		{
			// Only simulate these on new usercmds
			if ( !IsFirstTimePredicted() )
				continue;

			entity->PhysicsSimulate();
		}
		else
		{
			entity->PhysicsSimulate();
		}

		// Don't update last networked data here!!!
		entity->OnLatchInterpolatedVariables( LATCH_SIMULATION_VAR | LATCH_ANIMATION_VAR | INTERPOLATE_OMIT_UPDATE_LAST_NETWORKED );
	}

	// Only call the physics update for the entire physics system if we support predicted physics.
	if ( cl_predictphysics.GetBool() )
	{
		PhysicsSimulate();
	}
	
	// Always reset after running command
	IPredictionSystem::SuppressEvents( false );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPrediction::Untouch( int nSlot )
{
#if !defined( NO_ENTITY_PREDICTION )
	int numpredictables = GetPredictables( nSlot )->GetPredictableCount();

	// Loop through all entities again, checking their untouch if flagged to do so
	int i;
	for ( i = 0; i < numpredictables; i++ )
	{
		C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );
		if ( !entity )
			continue;

		if ( !entity->GetCheckUntouch() )
			continue;

		entity->PhysicsCheckForEntityUntouch();
	}
#endif
}

void CPrediction::StorePredictionResults( int nSlot, int predicted_frame )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::StorePredictionResults" );
	PREDICTION_TRACKVALUECHANGESCOPE( "save" );

	int c = GetPredictables( nSlot )->GetPredictableCount();

	// Now save off all of the results
	for ( int i = 0; i < c; ++i )
	{
		C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );
		if ( !entity )
			continue;

		// Certain entities can be created locally and if so created, should be 
		//  simulated until a network update arrives
		if ( !entity->GetPredictable() )
			continue;

		// FIXME: The lack of this call inexplicably actually creates prediction errors
		InvalidateEFlagsRecursive( entity, EFL_DIRTY_ABSTRANSFORM | EFL_DIRTY_ABSVELOCITY | EFL_DIRTY_ABSANGVELOCITY );
		entity->SaveData( "StorePredictionResults", predicted_frame, PC_EVERYTHING );
		
		//if we're keeping first frame results, copy them now
		if( m_Split[ nSlot ].m_bFirstTimePredicted && (entity->m_pIntermediateData_FirstPredicted[0] != NULL) )
		{
			entity->m_nIntermediateData_FirstPredictedShiftMarker = predicted_frame + 1;
			memcpy( entity->m_pIntermediateData_FirstPredicted[predicted_frame + 1], entity->m_pIntermediateData[predicted_frame], entity->GetPredDescMap()->m_nPackedSize );
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : slots_to_remove - 
//			previous_last_slot - 
//-----------------------------------------------------------------------------
void CPrediction::ShiftIntermediateDataForward( int nSlot, int slots_to_remove, int number_of_commands_run )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::ShiftIntermediateDataForward" );
	PREDICTION_TRACKVALUECHANGESCOPE( "shift" );

	if ( !C_BasePlayer::HasAnyLocalPlayer() )
		return;

	// Don't screw up memory of current player from history buffers if not filling in history buffers
	//  during prediction!!!
	if ( !cl_predict->GetInt() )
		return;

	int c = GetPredictables( nSlot )->GetPredictableCount();
	int i;
	for ( i = 0; i < c; i++ )
	{
		C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
		if ( !ent )
			continue;

		if ( !ent->GetPredictable() )
			continue;

		ent->ShiftIntermediateDataForward( slots_to_remove, number_of_commands_run );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : slots_to_remove - 
//-----------------------------------------------------------------------------
void CPrediction::ShiftFirstPredictedIntermediateDataForward( int nSlot, int slots_to_remove )
{
#if !defined( NO_ENTITY_PREDICTION )
	if( (slots_to_remove == 0) || (slots_to_remove >= MULTIPLAYER_BACKUP)  )
		return;

	VPROF( "CPrediction::ShiftFirstPredictedIntermediateDataForward" );
	PREDICTION_TRACKVALUECHANGESCOPE( "shift" );

	if ( !C_BasePlayer::HasAnyLocalPlayer() )
		return;

	// Don't screw up memory of current player from history buffers if not filling in history buffers
	//  during prediction!!!
	if ( !cl_predict->GetInt() )
		return;

	int c = GetPredictables( nSlot )->GetPredictableCount();
	int i;
	for ( i = 0; i < c; i++ )
	{
		C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
		if ( !ent )
			continue;

		if ( !ent->GetPredictable() )
			continue;

		ent->ShiftFirstPredictedIntermediateDataForward( slots_to_remove );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : predicted_frame - 
//-----------------------------------------------------------------------------
void CPrediction::RestoreEntityToPredictedFrame( int nSlot, int predicted_frame )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::RestoreEntityToPredictedFrame" );
	PREDICTION_TRACKVALUECHANGESCOPE( "restoretopred" );

	if ( !C_BasePlayer::GetLocalPlayer( nSlot ) )
		return;

	// Don't screw up memory of current player from history buffers if not filling in history buffers
	//  during prediction!!!
	if ( !cl_predict->GetInt() )
		return;

	int c = GetPredictables( nSlot )->GetPredictableCount();
	int i;
	for ( i = 0; i < c; i++ )
	{
		C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
		if ( !ent )
			continue;

		if ( !ent->GetPredictable() )
			continue;

		ent->RestoreData( "RestoreEntityToPredictedFrame", predicted_frame, PC_EVERYTHING );
		ent->OnPostRestoreData();
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Computes starting destination for intermediate prediction data results and
//  does any fixups required by network optimization
// Input  : received_new_world_update - 
//			incoming_acknowledged - 
// Output : int
//-----------------------------------------------------------------------------
int CPrediction::ComputeFirstCommandToExecute( int nSlot, bool received_new_world_update, int incoming_acknowledged, int outgoing_command )
{
	int destination_slot = 1;
#if !defined( NO_ENTITY_PREDICTION )
	int skipahead = 0;

	Split_t &split = m_Split[ nSlot ];

	// If we didn't receive a new update ( or we received an update that didn't ack any new CUserCmds -- 
	//  so for the player it should be just like receiving no update ), just jump right up to the very 
	//  last command we created for this very frame since we probably wouldn't have had any errors without 
	//  being notified by the server of such a case.
	// NOTE:  received_new_world_update only gets set to false if cl_pred_optimize >= 1
	if ( !received_new_world_update || !split.m_nServerCommandsAcknowledged )
	{
		if( !split.m_bPerformedTickShift )
		{
			// this is where we would normally start
			int start = incoming_acknowledged + 1;
			// outgoing_command is where we really want to start
			skipahead = MAX( 0, ( outgoing_command - start ) );
			// Don't start past the last predicted command, though, or we'll get prediction errors
			skipahead = MIN( skipahead, split.m_nCommandsPredicted );

			// Always restore since otherwise we might start prediction using an "interpolated" value instead of a purely predicted value
			RestoreEntityToPredictedFrame( nSlot, skipahead - 1 );

			//Msg( "%i/%i no world, skip to %i restore from slot %i\n", 
			//	gpGlobals->framecount,
			//	gpGlobals->tickcount,
			//	skipahead,
			//	skipahead - 1 );
		}
	}
	else
	{
		// Otherwise, there is a second optimization, wherein if we did receive an update, but no
		//  values differed (or were outside their epsilon) and the server actually acknowledged running
		//  one or more commands, then we can revert the entity to the predicted state from last frame, 
		//  shift the # of commands worth of intermediate state off of front the intermediate state array, and
		//  only predict the usercmd from the latest render frame.
		if ( cl_pred_optimize.GetInt() >= 2 && 
			!split.m_bPreviousAckHadErrors && 
			split.m_nCommandsPredicted > 0 && 
			split.m_nServerCommandsAcknowledged <= split.m_nCommandsPredicted &&
			!split.m_bPerformedTickShift )
		{
			// Copy all of the previously predicted data back into entity so we can skip repredicting it
			// This is the final slot that we previously predicted
			RestoreEntityToPredictedFrame( nSlot, split.m_nCommandsPredicted - 1 );

			// Shift intermediate state blocks down by # of commands ack'd
			ShiftIntermediateDataForward( nSlot, split.m_nServerCommandsAcknowledged, split.m_nCommandsPredicted );
			
			// Only predict new commands (note, this should be the same number that we could compute
			//  above based on outgoing_command - incoming_acknowledged - 1
			skipahead = ( split.m_nCommandsPredicted - split.m_nServerCommandsAcknowledged );

			//Msg( "%i/%i optimize2, skip to %i restore from slot %i\n", 
			//	gpGlobals->framecount,
			//	gpGlobals->tickcount,
			//	skipahead,
			//	split.m_nCommandsPredicted - 1 );
		}
		else
		{
			if( split.m_bPreviousAckHadErrors )
			{
				int count = GetPredictables( nSlot )->GetPredictableCount();
				for ( int i = 0; i < count; i++ )
				{
					C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
					if ( !ent )
						continue;

					ent->m_bEverHadPredictionErrorsForThisCommand = true; //this bool will get pulled forward until a new command is predicted for the first time
				}
			}

			if ( ( split.m_bPreviousAckHadErrors && cl_pred_doresetlatch.GetBool() ) || 
				cl_pred_doresetlatch.GetInt() == 2 )
			{
				// Both players should have == time base, etc.
				C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer( nSlot );
				
				// If an entity gets a prediction error, then we want to clear out its interpolated variables
				// so we don't mix different samples at the same timestamps. We subtract 1 tick interval here because
				// if we don't, we'll have 3 interpolation entries with the same timestamp as this predicted
				// frame, so we won't be able to interpolate (which leads to jerky movement in the player when
				// ANY entity like your gun gets a prediction error).
				float flPrev = gpGlobals->curtime;
				gpGlobals->curtime = pLocalPlayer->GetTimeBase() - TICK_INTERVAL;

				if( split.m_bPreviousAckErrorTriggersFullLatchReset || (cl_pred_doresetlatch.GetInt() == 2) )
				{				
					for ( int i = 0; i < GetPredictables( nSlot )->GetPredictableCount(); i++ )
					{
						C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );
						if ( entity )
						{
							entity->ResetLatched();
						}
					}
				}
				else
				{
					//individual latch resets
					for ( int i = 0; i < split.m_EntsWithPredictionErrorsInLastAck.Count(); i++ )
					{
						C_BaseEntity *entity = split.m_EntsWithPredictionErrorsInLastAck[i];
						if( entity )
						{
							//ensure it's still in our predictable list
							for ( int j = 0; j < GetPredictables( nSlot )->GetPredictableCount(); j++ )
							{
								if( entity == GetPredictables( nSlot )->GetPredictable( j ) )
								{
									entity->ResetLatched();
									break;
								}
							}
						}
					}
				}

				gpGlobals->curtime = flPrev;
			}
		}
	}

	ShiftFirstPredictedIntermediateDataForward( nSlot, split.m_nServerCommandsAcknowledged );

	destination_slot += skipahead;

	// Always reset these values now that we handled them
	split.m_nCommandsPredicted	= 0;
	split.m_bPreviousAckHadErrors = false;
	split.m_nServerCommandsAcknowledged = 0;
	split.m_bPerformedTickShift = false;
#endif
	return destination_slot;
}

//-----------------------------------------------------------------------------
// Actually does the prediction work, returns false if an error occurred
//-----------------------------------------------------------------------------
bool CPrediction::PerformPrediction( int nSlot, C_BasePlayer *localPlayer, bool received_new_world_update, int incoming_acknowledged, int outgoing_command )
{
	MDLCACHE_CRITICAL_SECTION();
#if !defined( NO_ENTITY_PREDICTION )
	VPROF( "CPrediction::PerformPrediction" );

	Assert( localPlayer );
	// This makes sure that we are allowed to sample the world when it may not be ready to be sampled
	Assert( C_BaseEntity::IsAbsQueriesValid() );
	Assert( C_BaseEntity::IsAbsRecomputationsEnabled() );

	// Start at command after last one server has processed and 
	//  go until we get to targettime or we run out of new commands
	int i = ComputeFirstCommandToExecute( nSlot, received_new_world_update, incoming_acknowledged, outgoing_command );

	Assert( i >= 1 );

	// This is a hack to get the CTriggerAutoGameMovement auto duck triggers to correctly deal with prediction.
	// Here we just untouch any triggers the player was touching (since we might have teleported the origin 
	// backward from it's previous position) and then re-touch any triggers it's currently in
#if !defined( PORTAL2 )	 //portal2 coop likes trigger touch behavior consistent with serverside trigger touch behavior
	localPlayer->SetCheckUntouch( true );
	localPlayer->PhysicsCheckForEntityUntouch();
#endif
	localPlayer->PhysicsTouchTriggers();

	// undo interpolation changes for entities we stand on
	C_BaseEntity *ground = localPlayer->GetGroundEntity();

	while ( ground && ground->entindex() > 0 )
	{
		ground->MoveToLastReceivedPosition();
		ground = ground->GetMoveParent();
	}

#if defined( PORTAL )
	if( cl_predicted_movement_uses_uninterpolated_physics.GetBool() )
	{
		//if we're going to treat physics objects as immovable solids on the client, they might as well be immovable solids in the place the server told us to put them
		//otherwise interpolation effectively teleports it backwards without the need (or support) to push entities backwards with it.
		//If you happen to be pushing a physics object, this will make movement traces freak out as we start in solid.
		MoveUnpredictedPhysicsNearPlayerToNetworkedPosition( localPlayer );
	}
#endif

	Split_t &split = m_Split[ nSlot ];
	
	physenv->DoneReferencingPreviousCommands( incoming_acknowledged - 1 );

	bool bTooMany = outgoing_command - incoming_acknowledged >= MULTIPLAYER_BACKUP;

	while ( !bTooMany )
	{
		// Incoming_acknowledged is the last usercmd the server acknowledged having acted upon
		int current_command		= incoming_acknowledged + i;

		// We've caught up to the current command.
		if ( current_command > outgoing_command )
			break;

		CUserCmd *cmd = input->GetUserCmd( nSlot, current_command );
		if ( !cmd )
		{
			bTooMany = true;
			break;	
		}

		Assert( i < MULTIPLAYER_BACKUP );

		// Is this the first time predicting this
		split.m_bFirstTimePredicted = !cmd->hasbeenpredicted;
#if defined( KEEP_COMMAND_REPREDICTION_COUNT )
		split.m_Debug_RepredictionCount = cmd->debug_RepredictionCount;
#endif

		// Set globals appropriately
		float curtime		= ( localPlayer->m_nTickBase ) * TICK_INTERVAL;

		if( physenv->IsPredicted() )
		{
			physenv->SetPredictionCommandNum( current_command );

			if( (m_Split[ nSlot ].m_nCommandsPredicted == 0) && (i == 1) )
			{
				if( !m_Split[ nSlot ].m_bFirstTimePredicted )
				{
					for ( int j = 0; j < GetPredictables( nSlot )->GetPredictableCount(); j++ )
					{
						C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( j );

						if( entity->m_bEverHadPredictionErrorsForThisCommand )
						{
							// Always reset
							gpGlobals->curtime		= curtime;
							gpGlobals->frametime	= m_bEnginePaused ? 0 : TICK_INTERVAL;				

							const byte *predictedFrame = (const byte *)entity->GetFirstPredictedFrame( 0 );
							entity->VPhysicsCompensateForPredictionErrors( predictedFrame );
						}
					}
				}
				//else - if lag is so low that we only predict every command once, do we need to keep around old data to base our corrections on?
			}
		}

		if( !cmd->hasbeenpredicted )
		{
			int count = GetPredictables( nSlot )->GetPredictableCount();
			for ( int i = 0; i < count; ++i )
			{
				C_BaseEntity *entity = GetPredictables( nSlot )->GetPredictable( i );

				if( entity )
				{
					entity->m_bEverHadPredictionErrorsForThisCommand = false;
				}
			}
		}

		RunSimulation( current_command, curtime, cmd, localPlayer );

		gpGlobals->curtime		= curtime;
		gpGlobals->frametime	= m_bEnginePaused ? 0 : TICK_INTERVAL;

		// Call untouch on any entities no longer predicted to be touching
		Untouch( nSlot );

		// Store intermediate data into appropriate slot
		StorePredictionResults( nSlot, i - 1 ); // Note that I starts at 1

		split.m_nCommandsPredicted = i;

		if ( current_command == outgoing_command )
		{
			localPlayer->m_nFinalPredictedTick = localPlayer->m_nTickBase;
		}

		// Mark that we issued any needed sounds, of not done already
		cmd->hasbeenpredicted = true;

#if defined( KEEP_COMMAND_REPREDICTION_COUNT )
		++cmd->debug_RepredictionCount;
#endif

		// Copy the state over.
		i++;
	}

	// Somehow we looped past the end of the list (severe lag), don't predict at all
	return !bTooMany;
#endif
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : startframe - 
//			validframe - 
//			incoming_acknowledged - 
//			outgoing_command - 
//-----------------------------------------------------------------------------
void CPrediction::Update( int startframe, bool validframe, 
						 int incoming_acknowledged, int outgoing_command )
{
#if !defined( NO_ENTITY_PREDICTION )
	VPROF_BUDGET( "CPrediction::Update", VPROF_BUDGETGROUP_PREDICTION );

	m_bEnginePaused = engine->IsPaused();

	bool received_new_world_update = true;

	// HACK!
	float flTimeStamp = engine->GetLastTimeStamp();
	bool bTimeStampChanged = m_flLastServerWorldTimeStamp != flTimeStamp;
	m_flLastServerWorldTimeStamp = flTimeStamp;

	// Still starting at same frame, so make sure we don't do extra prediction ,etc.
	if ( ( m_nPreviousStartFrame == startframe ) && 
		cl_pred_optimize.GetBool() &&
		cl_predict->GetInt() && bTimeStampChanged )
	{
		received_new_world_update = false;
	}

	m_nPreviousStartFrame = startframe;

	// Save off current timer values, etc.
	m_SavedVars = *gpGlobals;

	FOR_EACH_VALID_SPLITSCREEN_PLAYER( nSlot )
	{
		ACTIVE_SPLITSCREEN_PLAYER_GUARD( nSlot );
		_Update( nSlot, received_new_world_update, validframe, incoming_acknowledged, outgoing_command );
	}

	// Restore current timer values, etc.
	*gpGlobals = m_SavedVars;
#endif
}

//-----------------------------------------------------------------------------
// Do the dirty deed of predicting the local player
//-----------------------------------------------------------------------------
void CPrediction::_Update( int nSlot, bool received_new_world_update, bool validframe, 
						 int incoming_acknowledged, int outgoing_command )
{
#if !defined( NO_ENTITY_PREDICTION )

	QAngle viewangles;

	C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer( nSlot );
	if ( !localPlayer )
		return;

	m_Split[nSlot].m_nLastCommandAcknowledged = incoming_acknowledged;

	// Always using current view angles no matter what
	// NOTE: ViewAngles are always interpreted as being *relative* to the player
	engine->GetViewAngles( viewangles );
	localPlayer->SetLocalAngles( viewangles );

	if ( !validframe )
	{
		return;
	}

	// If we are not doing prediction, copy authoritative value into velocity and angle.
	if ( !cl_predict->GetInt() )
	{
		// When not predicting, we at least must make sure the player
		// view angles match the view angles...
		localPlayer->SetLocalViewAngles( viewangles );
		return;
	}

	// This is cheesy, but if we have entities that are parented to attachments on other entities, then 
	// it'll wind up needing to get a bone transform.
	{
		C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );

		// Invalidate bone cache on predictables
		int c = GetPredictables( nSlot )->GetPredictableCount();
		for ( int i = 0; i < c; ++i )
		{
			C_BaseEntity *ent = GetPredictables( nSlot )->GetPredictable( i );
			if ( !ent || 
				 !ent->GetBaseAnimating() || 
				 !ent->GetPredictable() )
				continue;
			static_cast< C_BaseAnimating * >( ent )->InvalidateBoneCache();
		}

		// Remove any purely client predicted entities that were left "dangling" because the 
		//  server didn't acknowledge them or which can now safely be removed
		RemoveStalePredictedEntities( nSlot, incoming_acknowledged );
		// Restore objects back to "pristine" state from last network/world state update
		if ( received_new_world_update )
		{
			RestoreOriginalEntityState( nSlot );
		}

		m_bInPrediction = true;
		bool bValid = PerformPrediction( nSlot, localPlayer, received_new_world_update, incoming_acknowledged, outgoing_command );
		m_bInPrediction = false;
		if ( !bValid )
		{
			return;
		}
	}

	// Overwrite predicted angles with the actual view angles
	localPlayer->SetLocalAngles( viewangles );

	// This allows us to sample the world when it may not be ready to be sampled
	Assert( C_BaseEntity::IsAbsQueriesValid() );
	
#ifndef CSTRIKE15 // this doesn't seem like it's applicable to the local cstrike player?
	SetIdealPitch( nSlot, localPlayer, localPlayer->GetLocalOrigin(), localPlayer->GetLocalAngles(), localPlayer->m_vecViewOffset );
#endif

#endif
}



//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPrediction::IsFirstTimePredicted( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
	return m_Split[ GET_ACTIVE_SPLITSCREEN_SLOT() ].m_bFirstTimePredicted;
#else
	return false;
#endif
}

#if defined( KEEP_COMMAND_REPREDICTION_COUNT )
unsigned int CPrediction::GetRepredictionCount( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
	return m_Split[ GET_ACTIVE_SPLITSCREEN_SLOT() ].m_Debug_RepredictionCount;
#else
	return 0;
#endif
}
#endif



//-----------------------------------------------------------------------------
// Purpose: For verifying/fixing operations that don't save/load in a datatable very well
// Output : Returns the how many commands the server has processed and sent results for
//-----------------------------------------------------------------------------
int CPrediction::GetLastAcknowledgedCommandNumber( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
	return m_Split[ GET_ACTIVE_SPLITSCREEN_SLOT() ].m_nLastCommandAcknowledged;
#else
	return 0;
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : org - 
//-----------------------------------------------------------------------------
void CPrediction::GetViewOrigin( Vector& org )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
	{
		org.Init();
	}
	else 
	{
		org = player->GetLocalOrigin();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : org - 
//-----------------------------------------------------------------------------
void CPrediction::SetViewOrigin( Vector& org )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
		return;

	player->SetLocalOrigin( org );
	player->m_vecNetworkOrigin = org;

	player->m_iv_vecOrigin.Reset( gpGlobals->curtime );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : ang - 
//-----------------------------------------------------------------------------
void CPrediction::GetViewAngles( QAngle& ang )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
	{
		ang.Init();
	}
	else 
	{
		ang = player->GetLocalAngles();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : ang - 
//-----------------------------------------------------------------------------
void CPrediction::SetViewAngles( QAngle& ang )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
		return;

	player->SetViewAngles( ang );
	player->m_iv_angRotation.Reset( gpGlobals->curtime );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : ang - 
//-----------------------------------------------------------------------------
void CPrediction::GetLocalViewAngles( QAngle& ang )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
	{
		ang.Init();
	}
	else 
	{
		ang = player->pl.v_angle;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : ang - 
//-----------------------------------------------------------------------------
void CPrediction::SetLocalViewAngles( QAngle& ang )
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
		return;

	player->SetLocalViewAngles( ang );
}

#if !defined( NO_ENTITY_PREDICTION )
//-----------------------------------------------------------------------------
// Purpose: For determining that predicted creation entities are un-acked and should
//  be deleted
// Output : int
//-----------------------------------------------------------------------------
int CPrediction::GetIncomingPacketNumber( void ) const
{
	return m_nIncomingPacketNumber;
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPrediction::InPrediction( void ) const
{
#if !defined( NO_ENTITY_PREDICTION )
	return m_bInPrediction;
#else
	return false;
#endif
}

float CPrediction::GetSavedTime() const
{
	return m_SavedVars.curtime;
}


#if (PREDICTION_ERROR_CHECK_LEVEL > 0)
bool _Easy_DiffPrint_InternalConditions( C_BaseEntity *pEntity )
{
	return (pEntity->GetPredictable() && prediction->InPrediction());
}
#endif