Fix line endings. WHAMMY.

1 files changed, 2073 insertions, 2073 deletions

diff --git a/mp/src/game/server/physics_main.cpp b/mp/src/game/server/physics_main.cpp
index 41d5625b..b0b2d867 100644
--- a/mp/src/game/server/physics_main.cpp
+++ b/mp/src/game/server/physics_main.cpp
@@ -1,2073 +1,2073 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: Physics simulation for non-havok/ipion objects

-//

-// $NoKeywords: $

-//=============================================================================//

-

-

-#include "cbase.h"

-#ifdef _WIN32

-#include "typeinfo.h"

-// BUGBUG: typeinfo stomps some of the warning settings (in yvals.h)

-#pragma warning(disable:4244)

-#elif POSIX

-#include <typeinfo>

-#else

-#error "need typeinfo defined"

-#endif

-

-#include "player.h"

-#include "ai_basenpc.h"

-#include "gamerules.h"

-#include "vphysics_interface.h"

-#include "mempool.h"

-#include "entitylist.h"

-#include "engine/IEngineSound.h"

-#include "datacache/imdlcache.h"

-#include "ispatialpartition.h"

-#include "tier0/vprof.h"

-#include "movevars_shared.h"

-#include "hierarchy.h"

-#include "trains.h"

-#include "vphysicsupdateai.h"

-#include "tier0/vcrmode.h"

-#include "pushentity.h"

-

-// memdbgon must be the last include file in a .cpp file!!!

-#include "tier0/memdbgon.h"

-

-extern ConVar think_limit;

-#ifdef _XBOX

-ConVar vprof_think_limit( "vprof_think_limit", "0" );

-#endif

-

-ConVar vprof_scope_entity_thinks( "vprof_scope_entity_thinks", "0" );

-ConVar vprof_scope_entity_gamephys( "vprof_scope_entity_gamephys", "0" );

-

-ConVar	npc_vphysics	( "npc_vphysics","0");

-//-----------------------------------------------------------------------------

-// helper method for trace hull as used by physics...

-//-----------------------------------------------------------------------------

-static void Physics_TraceEntity( CBaseEntity* pBaseEntity, const Vector &vecAbsStart,

-	const Vector &vecAbsEnd, unsigned int mask, trace_t *ptr )

-{

-	// FIXME: I really am not sure the best way of doing this

-	// The TraceHull code below for shots will make sure the object passes

-	// through shields which do not block that damage type. It will also 

-	// send messages to the shields that they've been hit.

-	if (pBaseEntity->GetDamageType() != DMG_GENERIC)

-	{

-		GameRules()->WeaponTraceEntity( pBaseEntity, vecAbsStart, vecAbsEnd, mask, ptr );

-	}

-	else

-	{

-		UTIL_TraceEntity( pBaseEntity, vecAbsStart, vecAbsEnd, mask, ptr );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Does not change the entities velocity at all

-// Input  : push - 

-// Output : trace_t

-//-----------------------------------------------------------------------------

-static void PhysicsCheckSweep( CBaseEntity *pEntity, const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace )

-{

-	unsigned int mask = pEntity->PhysicsSolidMaskForEntity();

-

-	Vector vecAbsEnd;

-	VectorAdd( vecAbsStart, vecAbsDelta, vecAbsEnd );

-

-	// Set collision type

-	if ( !pEntity->IsSolid() || pEntity->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS) )

-	{

-		if ( pEntity->GetMoveParent() )

-		{

-			UTIL_ClearTrace( *pTrace );

-			return;

-		}

-

-		// don't collide with monsters

-		mask &= ~CONTENTS_MONSTER;

-	}

-

-	Physics_TraceEntity( pEntity, vecAbsStart, vecAbsEnd, mask, pTrace );

-}

-

-CPhysicsPushedEntities s_PushedEntities;

-#ifndef TF_DLL

-CPhysicsPushedEntities *g_pPushedEntities = &s_PushedEntities;

-#endif

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-CPhysicsPushedEntities::CPhysicsPushedEntities( void ) : m_rgPusher(8, 8), m_rgMoved(32, 32)

-{

-	m_flMoveTime = -1.0f;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Store off entity and copy original origin to temporary array

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::AddEntity( CBaseEntity *ent )

-{

-	int i = m_rgMoved.AddToTail();

-	m_rgMoved[i].m_pEntity = ent;

-	m_rgMoved[i].m_vecStartAbsOrigin = ent->GetAbsOrigin();

-}

-

-

-//-----------------------------------------------------------------------------

-// Unlink + relink the pusher list so we can actually do the push

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::UnlinkPusherList( int *pPusherHandles )

-{

-	for ( int i = m_rgPusher.Count(); --i >= 0; )

-	{

-		pPusherHandles[i] = partition->HideElement( m_rgPusher[i].m_pEntity->CollisionProp()->GetPartitionHandle() );

-	}

-}

-

-void CPhysicsPushedEntities::RelinkPusherList( int *pPusherHandles )

-{

-	for ( int i = m_rgPusher.Count(); --i >= 0; )

-	{

-		partition->UnhideElement( m_rgPusher[i].m_pEntity->CollisionProp()->GetPartitionHandle(), pPusherHandles[i] );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Compute the direction to move the rotation blocker

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::ComputeRotationalPushDirection( CBaseEntity *pBlocker, const RotatingPushMove_t &rotPushMove, Vector *pMove, CBaseEntity *pRoot )

-{

-	// calculate destination position

-	// "start" is relative to the *root* pusher, world orientation

-	Vector start = pBlocker->CollisionProp()->GetCollisionOrigin();

-	if ( pRoot->GetSolid() == SOLID_VPHYSICS )

-	{

-		// HACKHACK: Use move dir to guess which corner of the box determines contact and rotate the box so

-		// that corner remains in the same local position.

-		// BUGBUG: This will break, but not as badly as the previous solution!!!

-		Vector vecAbsMins, vecAbsMaxs;

-		pBlocker->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );

-		start.x = (pMove->x < 0) ? vecAbsMaxs.x : vecAbsMins.x;

-		start.y = (pMove->y < 0) ? vecAbsMaxs.y : vecAbsMins.y;

-		start.z = (pMove->z < 0) ? vecAbsMaxs.z : vecAbsMins.z;

-		

-		CBasePlayer *pPlayer = ToBasePlayer(pBlocker);

-		if ( pPlayer )

-		{

-			// notify the player physics code so it can use vphysics to keep players from getting stuck

-			pPlayer->SetPhysicsFlag( PFLAG_GAMEPHYSICS_ROTPUSH, true );

-		}

-	}

-

-	// org is pusher local coordinate of start

-	Vector local;

-	// transform starting point into local space

-	VectorITransform( start, rotPushMove.startLocalToWorld, local );

-	// rotate local org into world space at end of rotation

-	Vector end;

-	VectorTransform( local, rotPushMove.endLocalToWorld, end );

-

-	// move is the difference (in world space) that the move will push this object

-	VectorSubtract( end, start, *pMove );

-}

-

-class CTraceFilterPushFinal : public CTraceFilterSimple

-{

-	DECLARE_CLASS( CTraceFilterPushFinal, CTraceFilterSimple );

-

-public:

-	CTraceFilterPushFinal( CBaseEntity *pEntity, int nCollisionGroup ) 

-		: CTraceFilterSimple( pEntity, nCollisionGroup )

-	{

-	

-	}

-

-	bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )

-	{

-		Assert( dynamic_cast<CBaseEntity*>(pHandleEntity) );

-		CBaseEntity *pTestEntity = static_cast<CBaseEntity*>(pHandleEntity);

-

-		// UNDONE: This should really filter to just the pushing entities

-		if ( pTestEntity->GetMoveType() == MOVETYPE_VPHYSICS && 

-			pTestEntity->VPhysicsGetObject() && pTestEntity->VPhysicsGetObject()->IsMoveable() )

-			return false;

-

-		return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );

-	}

-

-};

-

-bool CPhysicsPushedEntities::IsPushedPositionValid( CBaseEntity *pBlocker )

-{

-	CTraceFilterPushFinal pushFilter(pBlocker, pBlocker->GetCollisionGroup() );

-

-	trace_t trace;

-	UTIL_TraceEntity( pBlocker, pBlocker->GetAbsOrigin(), pBlocker->GetAbsOrigin(), pBlocker->PhysicsSolidMaskForEntity(), &pushFilter, &trace );

-

-	return !trace.startsolid;

-}

-

-//-----------------------------------------------------------------------------

-// Speculatively checks to see if all entities in this list can be pushed

-//-----------------------------------------------------------------------------

-bool CPhysicsPushedEntities::SpeculativelyCheckPush( PhysicsPushedInfo_t &info, const Vector &vecAbsPush, bool bRotationalPush )

-{

-	CBaseEntity *pBlocker = info.m_pEntity;

-

-	// See if it's possible to move the entity, but disable all pushers in the hierarchy first

-	int *pPusherHandles = (int*)stackalloc( m_rgPusher.Count() * sizeof(int) );

-	UnlinkPusherList( pPusherHandles );

-	CTraceFilterPushMove pushFilter(pBlocker, pBlocker->GetCollisionGroup() );

-

-	Vector pushDestPosition = pBlocker->GetAbsOrigin() + vecAbsPush;

-	UTIL_TraceEntity( pBlocker, pBlocker->GetAbsOrigin(), pushDestPosition, 

-		pBlocker->PhysicsSolidMaskForEntity(), &pushFilter, &info.m_Trace );

-

-	RelinkPusherList(pPusherHandles);

-	info.m_bPusherIsGround = false;

-	if ( pBlocker->GetGroundEntity() && pBlocker->GetGroundEntity()->GetRootMoveParent() == m_rgPusher[0].m_pEntity )

-	{

-		info.m_bPusherIsGround = true;

-	}

-

-	bool bIsUnblockable = (m_bIsUnblockableByPlayer && (pBlocker->IsPlayer() || pBlocker->MyNPCPointer())) ? true : false;

-	if ( bIsUnblockable )

-	{

-		pBlocker->SetAbsOrigin( pushDestPosition );

-	}

-	else

-	{

-		// Move the blocker into its new position

-		if ( info.m_Trace.fraction )

-		{

-			pBlocker->SetAbsOrigin( info.m_Trace.endpos );

-		}

-

-		// We're not blocked if the blocker is point-sized or non-solid

-		if ( pBlocker->IsPointSized() || !pBlocker->IsSolid() || 

-			pBlocker->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )

-		{

-			return true;

-		}

-

-		if ( (!bRotationalPush) && (info.m_Trace.fraction == 1.0) )

-		{

-			//Assert( pBlocker->PhysicsTestEntityPosition() == false );

-			if ( !IsPushedPositionValid(pBlocker) )

-			{

-				Warning("Interpenetrating entities! (%s and %s)\n",

-					pBlocker->GetClassname(), m_rgPusher[0].m_pEntity->GetClassname() );

-			}

-

-			return true;

-		}

-	}

-

-	// Check to see if we're still blocked by the pushers

-	// FIXME: If the trace fraction == 0 can we early out also?

-	info.m_bBlocked = !IsPushedPositionValid(pBlocker);

-

-	if ( !info.m_bBlocked )

-		return true;

-

-	// if the player is blocking the train try nudging him around to fix accumulated error

-	if ( bIsUnblockable )

-	{

-		Vector org = pBlocker->GetAbsOrigin();

-		for ( int checkCount = 0; checkCount < 4; checkCount++ )

-		{

-			Vector move;

-			MatrixGetColumn( m_rgPusher[0].m_pEntity->EntityToWorldTransform(), checkCount>>1, move );

-			

-			// alternate movements 1/2" in each direction

-			float factor = ( checkCount & 1 ) ? -0.5f : 0.5f;

-			pBlocker->SetAbsOrigin( org + move * factor );

-			info.m_bBlocked = !IsPushedPositionValid(pBlocker);

-			if ( !info.m_bBlocked )

-				return true;

-		}

-		pBlocker->SetAbsOrigin( pushDestPosition );

-

-#ifndef TF_DLL

-		DevMsg(1, "Ignoring player blocking train!\n");

-#endif

-		return true;

-	}

-	return false;

-}

-

-

-//-----------------------------------------------------------------------------

-// Speculatively checks to see if all entities in this list can be pushed

-//-----------------------------------------------------------------------------

-bool CPhysicsPushedEntities::SpeculativelyCheckRotPush( const RotatingPushMove_t &rotPushMove, CBaseEntity *pRoot )

-{

-	Vector vecAbsPush;

-	m_nBlocker = -1;

-	for (int i = m_rgMoved.Count(); --i >= 0; )

-	{

-		ComputeRotationalPushDirection( m_rgMoved[i].m_pEntity, rotPushMove, &vecAbsPush, pRoot );

-		if (!SpeculativelyCheckPush( m_rgMoved[i], vecAbsPush, true ))

-		{

-			m_nBlocker = i;

-			return false;

-		}

-	}

-

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// Speculatively checks to see if all entities in this list can be pushed

-//-----------------------------------------------------------------------------

-bool CPhysicsPushedEntities::SpeculativelyCheckLinearPush( const Vector &vecAbsPush )

-{

-	m_nBlocker = -1;

-	for (int i = m_rgMoved.Count(); --i >= 0; )

-	{

-		if (!SpeculativelyCheckPush( m_rgMoved[i], vecAbsPush, false ))

-		{

-			m_nBlocker = i;

-			return false;

-		}

-	}

-

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// Causes all entities in the list to touch triggers from their prev position

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::FinishPushers()

-{

-	// We succeeded! Now that we know the final location of all entities,

-	// touch triggers + update physics objects + do other fixup

-	for ( int i = m_rgPusher.Count(); --i >= 0; )

-	{

-		PhysicsPusherInfo_t &info = m_rgPusher[i];

-

-		// Cause touch functions to be called

-		// FIXME: Need to make moved entities not touch triggers until we know we're ok

-		// FIXME: it'd be better for the engine to just have a touch method

-		info.m_pEntity->PhysicsTouchTriggers( &info.m_vecStartAbsOrigin );

-

-		info.m_pEntity->UpdatePhysicsShadowToCurrentPosition( gpGlobals->frametime );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Causes all entities in the list to touch triggers from their prev position

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::FinishRotPushedEntity( CBaseEntity *pPushedEntity, const RotatingPushMove_t &rotPushMove )

-{

-	// Impart angular velocity of push onto pushed objects

-	if ( pPushedEntity->IsPlayer() )

-	{

-		QAngle angVel = pPushedEntity->GetLocalAngularVelocity();

-		angVel[1] = rotPushMove.amove[1];

-		pPushedEntity->SetLocalAngularVelocity(angVel);

-

-		// Look up associated client

-		CBasePlayer *player = ( CBasePlayer * )pPushedEntity;

-		player->pl.fixangle = FIXANGLE_RELATIVE;

-		// Because we can run multiple ticks per server frame, accumulate a total offset here instead of straight

-		//  setting it.  The engine will reset anglechange to 0 when the message is actually sent to the client

-		player->pl.anglechange += rotPushMove.amove;

-	}

-	else

-	{

-		QAngle angles = pPushedEntity->GetAbsAngles();

-		

-		// only rotate YAW with pushing.  Freely rotateable entities should either use VPHYSICS

-		// or be set up as children

-		angles.y += rotPushMove.amove.y;

-		pPushedEntity->SetAbsAngles( angles );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Causes all entities in the list to touch triggers from their prev position

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::FinishPush( bool bIsRotPush, const RotatingPushMove_t *pRotPushMove )

-{

-	FinishPushers();

-

-	for ( int i = m_rgMoved.Count(); --i >= 0; )

-	{

-		PhysicsPushedInfo_t &info = m_rgMoved[i];

-		CBaseEntity *pPushedEntity = info.m_pEntity;

-

-		// Cause touch functions to be called

-		// FIXME: it'd be better for the engine to just have a touch method

-		info.m_pEntity->PhysicsTouchTriggers( &info.m_vecStartAbsOrigin );

-		info.m_pEntity->UpdatePhysicsShadowToCurrentPosition( gpGlobals->frametime );

-		CAI_BaseNPC *pNPC = info.m_pEntity->MyNPCPointer();

-		if ( info.m_bPusherIsGround && pNPC )

-		{

-			pNPC->NotifyPushMove();

-		}

-

-

-		// Register physics impacts...

-		if (info.m_Trace.m_pEnt)

-		{

-			pPushedEntity->PhysicsImpact( info.m_Trace.m_pEnt, info.m_Trace );

-		}

-

-		if (bIsRotPush)

-		{

-			FinishRotPushedEntity( pPushedEntity, *pRotPushMove );

-		}

-	}

-}

-

-// save initial state when beginning a push sequence

-void CPhysicsPushedEntities::BeginPush( CBaseEntity *pRoot )

-{

-	m_rgMoved.RemoveAll();

-	m_rgPusher.RemoveAll();

-

-	m_rootPusherStartLocalOrigin = pRoot->GetLocalOrigin();

-	m_rootPusherStartLocalAngles = pRoot->GetLocalAngles();

-	m_rootPusherStartLocaltime = pRoot->GetLocalTime();

-}

-

-// store off a list of what has changed - so vphysicsUpdate can undo this if the object gets blocked

-void CPhysicsPushedEntities::StoreMovedEntities( physicspushlist_t &list )

-{

-	list.localMoveTime = m_rootPusherStartLocaltime;

-	list.localOrigin = m_rootPusherStartLocalOrigin;

-	list.localAngles = m_rootPusherStartLocalAngles;

-	list.pushedCount = CountMovedEntities();

-	Assert(list.pushedCount < ARRAYSIZE(list.pushedEnts));

-	if ( list.pushedCount > ARRAYSIZE(list.pushedEnts) )

-	{

-		list.pushedCount = ARRAYSIZE(list.pushedEnts);

-	}

-	for ( int i = 0; i < list.pushedCount; i++ )

-	{

-		list.pushedEnts[i] = m_rgMoved[i].m_pEntity;

-		list.pushVec[i] = m_rgMoved[i].m_pEntity->GetAbsOrigin() - m_rgMoved[i].m_vecStartAbsOrigin;

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Registers a blockage

-//-----------------------------------------------------------------------------

-CBaseEntity *CPhysicsPushedEntities::RegisterBlockage()

-{

-	Assert(	m_nBlocker >= 0 );

-

-	// Generate a PhysicsImpact against the blocker...

-	PhysicsPushedInfo_t &info = m_rgMoved[m_nBlocker];

-	if ( info.m_Trace.m_pEnt )

-	{

-		info.m_pEntity->PhysicsImpact( info.m_Trace.m_pEnt, info.m_Trace );

-	}

-

-	// This is the dude 

-	return info.m_pEntity;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Restore entities that might have been moved

-// Input  : fromrotation - if the move is from a rotation, then angular move must also be reverted

-//			*amove - 

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::RestoreEntities( )

-{

-	// Reset all of the pushed entities to get them back into place also

-	for ( int i = m_rgMoved.Count(); --i >= 0; )

-	{

-		m_rgMoved[ i ].m_pEntity->SetAbsOrigin( m_rgMoved[ i ].m_vecStartAbsOrigin );

-	}

-}

-

-

-

-

-//-----------------------------------------------------------------------------

-// Purpose: This is a trace filter that only hits an exclusive list of entities

-//-----------------------------------------------------------------------------

-class CTraceFilterAgainstEntityList : public ITraceFilter

-{

-public:

-	virtual bool ShouldHitEntity( IHandleEntity *pEntity, int contentsMask )

-	{

-		for ( int i = m_entityList.Count()-1; i >= 0; --i )

-		{

-			if ( m_entityList[i] == pEntity )

-				return true;

-		}

-

-		return false;

-	}

-

-	virtual TraceType_t	GetTraceType() const

-	{

-		return TRACE_ENTITIES_ONLY;

-	}

-

-	void AddEntityToHit( IHandleEntity *pEntity )

-	{

-		m_entityList.AddToTail(pEntity);

-	}

-

-	CUtlVector<IHandleEntity *>	m_entityList;

-};

-

-//-----------------------------------------------------------------------------

-// Generates a list of potential blocking entities

-//-----------------------------------------------------------------------------

-class CPushBlockerEnum : public IPartitionEnumerator

-{

-public:

-	CPushBlockerEnum( CPhysicsPushedEntities *pPushedEntities ) : m_pPushedEntities(pPushedEntities)

-	{

-		// All elements are part of the same hierarchy, so they all have

-		// the same root, so it doesn't matter which one we grab

-		m_pRootHighestParent = m_pPushedEntities->m_rgPusher[0].m_pEntity->GetRootMoveParent();

-		++s_nEnumCount;

-

-		m_collisionGroupCount = 0;

-		for ( int i = m_pPushedEntities->m_rgPusher.Count(); --i >= 0; )

-		{

-			if ( !m_pPushedEntities->m_rgPusher[i].m_pEntity->IsSolid() )

-				continue;

-

-			m_pushersOnly.AddEntityToHit( m_pPushedEntities->m_rgPusher[i].m_pEntity );

-			int collisionGroup = m_pPushedEntities->m_rgPusher[i].m_pEntity->GetCollisionGroup();

-			AddCollisionGroup(collisionGroup);

-		}

-

-	}

-

-	virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity )

-	{

-		CBaseEntity *pCheck = GetPushableEntity( pHandleEntity );

-		if ( !pCheck )

-			return ITERATION_CONTINUE;

-

-		// Mark it as seen

-		pCheck->m_nPushEnumCount = s_nEnumCount;

-		m_pPushedEntities->AddEntity( pCheck );

-

-		return ITERATION_CONTINUE;

-	}

-

-private:

-

-	inline void AddCollisionGroup(int collisionGroup)

-	{

-		for ( int i = 0; i < m_collisionGroupCount; i++ )

-		{

-			if ( m_collisionGroups[i] == collisionGroup )

-				return;

-		}

-		if ( m_collisionGroupCount < ARRAYSIZE(m_collisionGroups) )

-		{

-			m_collisionGroups[m_collisionGroupCount] = collisionGroup;

-			m_collisionGroupCount++;

-		}

-	}

-

-	bool IsStandingOnPusher( CBaseEntity *pCheck )

-	{

-		CBaseEntity *pGroundEnt = pCheck->GetGroundEntity();

-		if ( pCheck->GetFlags() & FL_ONGROUND || pGroundEnt )

-		{

-			for ( int i = m_pPushedEntities->m_rgPusher.Count(); --i >= 0; )

-			{

-				if (m_pPushedEntities->m_rgPusher[i].m_pEntity == pGroundEnt)

-				{

-					return true;

-				}

-			}

-		}

-		return false;

-	}

-

-	bool IntersectsPushers( CBaseEntity *pTest )

-	{

-		trace_t tr;

-

-		ICollideable *pCollision = pTest->GetCollideable();

-		enginetrace->SweepCollideable( pCollision, pTest->GetAbsOrigin(), pTest->GetAbsOrigin(), pCollision->GetCollisionAngles(), 

-			pTest->PhysicsSolidMaskForEntity(), &m_pushersOnly, &tr );

-

-		return tr.startsolid;

-	}

-

-	CBaseEntity *GetPushableEntity( IHandleEntity *pHandleEntity )

-	{

-		CBaseEntity *pCheck = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );

-		if ( !pCheck )

-			return NULL;

-

-		// Don't bother if we've already seen this one...

-		if (pCheck->m_nPushEnumCount == s_nEnumCount)

-			return NULL;

-

-		if ( !pCheck->IsSolid() )

-			return NULL;

-

-		if ( pCheck->GetMoveType() == MOVETYPE_PUSH || 

-			 pCheck->GetMoveType() == MOVETYPE_NONE || 

-			 pCheck->GetMoveType() == MOVETYPE_VPHYSICS ||

-			 pCheck->GetMoveType() == MOVETYPE_NOCLIP )

-		{

-			return NULL;

-		}

-

-		bool bCollide = false;

-		for ( int i = 0; i < m_collisionGroupCount; i++ )

-		{

-			if ( g_pGameRules->ShouldCollide( pCheck->GetCollisionGroup(), m_collisionGroups[i] ) )

-			{

-				bCollide = true;

-				break;

-			}

-		}

-		if ( !bCollide )

-			return NULL;

-		// We're not pushing stuff we're hierarchically attached to

-		CBaseEntity *pCheckHighestParent = pCheck->GetRootMoveParent();

-		if (pCheckHighestParent == m_pRootHighestParent)

-			return NULL;

-

-		// If we're standing on the pusher or any rigidly attached child

-		// of the pusher, we don't need to bother checking for interpenetration

-		if ( !IsStandingOnPusher(pCheck) )

-		{

-			// Our surrounding boxes are touching. But we may well not be colliding....

-			// see if the ent's bbox is inside the pusher's final position

-			if ( !IntersectsPushers( pCheck ) )

-				return NULL;

-		}

-

-		// NOTE: This is pretty tricky here. If a rigidly attached child comes into

-		// contact with a pusher, we *cannot* push the child. Instead, we must push

-		// the highest parent of that child.

-		return pCheckHighestParent;

-	}

-

-private:

-	static int s_nEnumCount;

-	CPhysicsPushedEntities *m_pPushedEntities;

-	CBaseEntity *m_pRootHighestParent;

-	CTraceFilterAgainstEntityList	m_pushersOnly;

-	int m_collisionGroups[8];

-	int m_collisionGroupCount;

-};

-

-int CPushBlockerEnum::s_nEnumCount = 0;

-

-//-----------------------------------------------------------------------------

-// Generates a list of potential blocking entities

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::GenerateBlockingEntityList()

-{

-	VPROF("CPhysicsPushedEntities::GenerateBlockingEntityList");

-

-	m_rgMoved.RemoveAll();

-	CPushBlockerEnum blockerEnum( this );

-

-	for ( int i = m_rgPusher.Count(); --i >= 0;  )

-	{

-		CBaseEntity *pPusher = m_rgPusher[i].m_pEntity;

-

-		// Don't bother if the pusher isn't solid

-		if ( !pPusher->IsSolid() || pPusher->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )

-		{

-			continue;

-		}

-

-		Vector vecAbsMins, vecAbsMaxs;

-		pPusher->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );

-		partition->EnumerateElementsInBox( PARTITION_ENGINE_NON_STATIC_EDICTS, vecAbsMins, vecAbsMaxs, false, &blockerEnum );

-

-		//Go back throught the generated list.

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Generates a list of potential blocking entities

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::GenerateBlockingEntityListAddBox( const Vector &vecMoved )

-{

-	VPROF("CPhysicsPushedEntities::GenerateBlockingEntityListAddBox");

-

-	m_rgMoved.RemoveAll();

-	CPushBlockerEnum blockerEnum( this );

-

-	for ( int i = m_rgPusher.Count(); --i >= 0;  )

-	{

-		CBaseEntity *pPusher = m_rgPusher[i].m_pEntity;

-

-		// Don't bother if the pusher isn't solid

-		if ( !pPusher->IsSolid() || pPusher->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )

-		{

-			continue;

-		}

-

-		Vector vecAbsMins, vecAbsMaxs;

-		pPusher->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );

-		for ( int iAxis = 0; iAxis < 3; ++iAxis )

-		{

-			if ( vecMoved[iAxis] >= 0.0f )

-			{

-				vecAbsMins[iAxis] -= vecMoved[iAxis];

-			}

-			else

-			{

-				vecAbsMaxs[iAxis] -= vecMoved[iAxis];

-			}

-		}

-

-		partition->EnumerateElementsInBox( PARTITION_ENGINE_NON_STATIC_EDICTS, vecAbsMins, vecAbsMaxs, false, &blockerEnum );

-

-		//Go back throught the generated list.

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Gets a list of all entities hierarchically attached to the root 

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::SetupAllInHierarchy( CBaseEntity *pParent )

-{

-	if (!pParent)

-		return;

-

-	VPROF("CPhysicsPushedEntities::SetupAllInHierarchy");

-

-	// Make sure to snack the position +before+ relink because applying the

-	// rotation (which occurs in relink) will put it at the final location

-	// NOTE: The root object at this point is actually at its final position.

-	// We'll fix that up later

-	int i = m_rgPusher.AddToTail();

-	m_rgPusher[i].m_pEntity = pParent;

-	m_rgPusher[i].m_vecStartAbsOrigin = pParent->GetAbsOrigin();

-

-	CBaseEntity *pChild;

-	for ( pChild = pParent->FirstMoveChild(); pChild != NULL; pChild = pChild->NextMovePeer() )

-	{

-		SetupAllInHierarchy( pChild );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Rotates the root entity, fills in the pushmove structure

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::RotateRootEntity( CBaseEntity *pRoot, float movetime, RotatingPushMove_t &rotation )

-{

-	VPROF("CPhysicsPushedEntities::RotateRootEntity");

-

-	rotation.amove = pRoot->GetLocalAngularVelocity() * movetime;

-	rotation.origin = pRoot->GetAbsOrigin();

-

-	// Knowing the initial + ending basis is needed for determining

-	// which corner we're pushing 

-	MatrixCopy( pRoot->EntityToWorldTransform(), rotation.startLocalToWorld );

-

-	// rotate the pusher to it's final position

-	QAngle angles = pRoot->GetLocalAngles();

-	angles += pRoot->GetLocalAngularVelocity() * movetime;

-

-	pRoot->SetLocalAngles( angles );

-	

-	// Compute the change in absangles

-	MatrixCopy( pRoot->EntityToWorldTransform(), rotation.endLocalToWorld );

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Tries to rotate an entity hierarchy, returns the blocker if any

-//-----------------------------------------------------------------------------

-CBaseEntity *CPhysicsPushedEntities::PerformRotatePush( CBaseEntity *pRoot, float movetime )

-{

-	VPROF("CPhysicsPushedEntities::PerformRotatePush");

-

-	m_bIsUnblockableByPlayer = (pRoot->GetFlags() & FL_UNBLOCKABLE_BY_PLAYER) ? true : false;

-	// Build a list of this entity + all its children because we're going to try to move them all

-	// This will also make sure each entity is linked in the appropriate place

-	// with correct absboxes

-	m_rgPusher.RemoveAll();

-	SetupAllInHierarchy( pRoot );

-

-	// save where we rotated from, in case we're blocked

-	QAngle angPrevAngles = pRoot->GetLocalAngles();

-

-	// Apply the rotation

-	RotatingPushMove_t	rotPushMove;

-	RotateRootEntity( pRoot, movetime, rotPushMove );

-

-	// Next generate a list of all entities that could potentially be intersecting with

-	// any of the children in their new locations...

-	GenerateBlockingEntityList( );

-

-	// Now we have a unique list of things that could potentially block our push

-	// and need to be pushed out of the way. Lets try to push them all out of the way.

-	// If we fail, undo it all

-	if (!SpeculativelyCheckRotPush( rotPushMove, pRoot ))

-	{

-		CBaseEntity *pBlocker = RegisterBlockage();

-		pRoot->SetLocalAngles( angPrevAngles );

-		RestoreEntities( );

-		return pBlocker;

-	}

-

-	FinishPush( true, &rotPushMove );

-	return NULL;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Linearly moves the root entity

-//-----------------------------------------------------------------------------

-void CPhysicsPushedEntities::LinearlyMoveRootEntity( CBaseEntity *pRoot, float movetime, Vector *pAbsPushVector )

-{

-	VPROF("CPhysicsPushedEntities::LinearlyMoveRootEntity");

-

-	// move the pusher to it's final position

-	Vector move = pRoot->GetLocalVelocity() * movetime;

-	Vector origin = pRoot->GetLocalOrigin();

-	origin += move;		

-	pRoot->SetLocalOrigin( origin );

-

-	// Store off the abs push vector

-	*pAbsPushVector = pRoot->GetAbsVelocity() * movetime;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Tries to linearly push an entity hierarchy, returns the blocker if any

-//-----------------------------------------------------------------------------

-CBaseEntity *CPhysicsPushedEntities::PerformLinearPush( CBaseEntity *pRoot, float movetime )

-{

-	VPROF("CPhysicsPushedEntities::PerformLinearPush");

-

-	m_flMoveTime = movetime;

-

-	m_bIsUnblockableByPlayer = (pRoot->GetFlags() & FL_UNBLOCKABLE_BY_PLAYER) ? true : false;

-	// Build a list of this entity + all its children because we're going to try to move them all

-	// This will also make sure each entity is linked in the appropriate place

-	// with correct absboxes

-	m_rgPusher.RemoveAll();

-	SetupAllInHierarchy( pRoot );

-

-	// save where we started from, in case we're blocked

-	Vector vecPrevOrigin = pRoot->GetLocalOrigin();

-

-	// Move the root (and all children) into its new position

-	Vector vecAbsPush;

-	LinearlyMoveRootEntity( pRoot, movetime, &vecAbsPush );

-

-	// Next generate a list of all entities that could potentially be intersecting with

-	// any of the children in their new locations...

-	GenerateBlockingEntityListAddBox( vecAbsPush );

-

-	// Now we have a unique list of things that could potentially block our push

-	// and need to be pushed out of the way. Lets try to push them all out of the way.

-	// If we fail, undo it all

-	if (!SpeculativelyCheckLinearPush( vecAbsPush ))

-	{

-		CBaseEntity *pBlocker = RegisterBlockage();

-		pRoot->SetLocalOrigin( vecPrevOrigin );

-		RestoreEntities();

-		return pBlocker;

-	}

-

-	FinishPush( );

-	return NULL;

-}

-

-

-

-//-----------------------------------------------------------------------------

-//

-// CBaseEntity methods

-//

-//-----------------------------------------------------------------------------

-

-//-----------------------------------------------------------------------------

-// Purpose: Called when it's time for a physically moved objects (plats, doors, etc)

-//			to run it's game code.

-//			All other entity thinking is done during worldspawn's think

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsDispatchThink( BASEPTR thinkFunc )

-{

-	VPROF_ENTER_SCOPE( ( !vprof_scope_entity_thinks.GetBool() ) ? 

-						"CBaseEntity::PhysicsDispatchThink" : 

-						EntityFactoryDictionary()->GetCannonicalName( GetClassname() ) );

-

-	float thinkLimit = think_limit.GetFloat();

-	

-	// The thinkLimit stuff makes a LOT of calls to Sys_FloatTime, which winds up calling into

-	// VCR mode so much that the framerate becomes unusable.

-	if ( VCRGetMode() != VCR_Disabled )

-		thinkLimit = 0;

-

-	float startTime = 0.0;

-

-	if ( IsDormant() )

-	{

-		Warning( "Dormant entity %s (%s) is thinking!!\n", GetClassname(), GetDebugName() );

-		Assert(0);

-	}

-

-	if ( thinkLimit )

-	{

-		startTime = engine->Time();

-	}

-	

-	if ( thinkFunc )

-	{

-		MDLCACHE_CRITICAL_SECTION();

-		(this->*thinkFunc)();

-	}

-

-	if ( thinkLimit )

-	{

-		// calculate running time of the AI in milliseconds

-		float time = ( engine->Time() - startTime ) * 1000.0f;

-		if ( time > thinkLimit )

-		{

-#if defined( _XBOX ) && !defined( _RETAIL )

-			if ( vprof_think_limit.GetBool() )

-			{

-				extern bool g_VProfSignalSpike;

-				g_VProfSignalSpike = true;

-			}

-#endif

-			// If its an NPC print out the shedule/task that took so long

-			CAI_BaseNPC *pNPC = MyNPCPointer();

-			if (pNPC && pNPC->GetCurSchedule())

-			{

-				pNPC->ReportOverThinkLimit( time );

-			}

-			else

-			{

-#ifdef _WIN32

-				Msg( "%s(%s) thinking for %.02f ms!!!\n", GetClassname(), typeid(this).raw_name(), time );

-#elif POSIX

-				Msg( "%s(%s) thinking for %.02f ms!!!\n", GetClassname(), typeid(this).name(), time );

-#else

-#error "typeinfo"

-#endif

-			}

-		}

-	}

-

-	VPROF_EXIT_SCOPE();

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Does not change the entities velocity at all

-// Input  : push - 

-// Output : trace_t

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsCheckSweep( const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace )

-{

-	::PhysicsCheckSweep( this, vecAbsStart, vecAbsDelta, pTrace );

-}

-

-

-

-#define	MAX_CLIP_PLANES	5

-//-----------------------------------------------------------------------------

-// Purpose: The basic solid body movement attempt/clip that slides along multiple planes

-// Input  : time - Amount of time to try moving for

-//			*steptrace - if not NULL, the trace results of any vertical wall hit will be stored

-// Output : int - the clipflags if the velocity was modified (hit something solid)

-//   1 = floor

-//   2 = wall / step

-//   4 = dead stop

-//-----------------------------------------------------------------------------

-int CBaseEntity::PhysicsTryMove( float flTime, trace_t *steptrace )

-{

-	VPROF("CBaseEntity::PhysicsTryMove");

-

-	int			bumpcount, numbumps;

-	Vector		dir;

-	float		d;

-	int			numplanes;

-	Vector		planes[MAX_CLIP_PLANES];

-	Vector		primal_velocity, original_velocity, new_velocity;

-	int			i, j;

-	trace_t		trace;

-	Vector		end;

-	float		time_left;

-	int			blocked;

-	

-	unsigned int mask = PhysicsSolidMaskForEntity();

-

-	new_velocity.Init();

-

-	numbumps = 4;

-

-	Vector vecAbsVelocity = GetAbsVelocity();

-

-	blocked = 0;

-	VectorCopy (vecAbsVelocity, original_velocity);

-	VectorCopy (vecAbsVelocity, primal_velocity);

-	numplanes = 0;

-	

-	time_left = flTime;

-

-	for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)

-	{

-		if (vecAbsVelocity == vec3_origin)

-			break;

-

-		VectorMA( GetAbsOrigin(), time_left, vecAbsVelocity, end );

-

-		Physics_TraceEntity( this, GetAbsOrigin(), end, mask, &trace );

-

-		if (trace.startsolid)

-		{	// entity is trapped in another solid

-			SetAbsVelocity(vec3_origin);

-			return 4;

-		}

-

-		if (trace.fraction > 0)

-		{	// actually covered some distance

-			SetAbsOrigin( trace.endpos );

-			VectorCopy (vecAbsVelocity, original_velocity);

-			numplanes = 0;

-		}

-

-		if (trace.fraction == 1)

-			 break;		// moved the entire distance

-

-		if (!trace.m_pEnt)

-		{

-			SetAbsVelocity( vecAbsVelocity );

-			Warning( "PhysicsTryMove: !trace.u.ent" );

-			Assert(0);

-			return 4;

-		}

-

-		if (trace.plane.normal[2] > 0.7)

-		{

-			blocked |= 1;		// floor

-			if (CanStandOn( trace.m_pEnt ))

-			{

-				// keep track of time when changing ground entity

-				if (GetGroundEntity() != trace.m_pEnt)

-				{

-					SetGroundChangeTime( gpGlobals->curtime + (flTime - (1 - trace.fraction) * time_left) );

-				}

-

-				SetGroundEntity( trace.m_pEnt );

-			}

-		}

-		if (!trace.plane.normal[2])

-		{

-			blocked |= 2;		// step

-			if (steptrace)

-				*steptrace = trace;	// save for player extrafriction

-		}

-

-		// run the impact function

-		PhysicsImpact( trace.m_pEnt, trace );

-		// Removed by the impact function

-		if ( IsMarkedForDeletion() || IsEdictFree() )

-			break;		

-	

-		time_left -= time_left * trace.fraction;

-		

-		// clipped to another plane

-		if (numplanes >= MAX_CLIP_PLANES)

-		{	// this shouldn't really happen

-			SetAbsVelocity(vec3_origin);

-			return blocked;

-		}

-

-		VectorCopy (trace.plane.normal, planes[numplanes]);

-		numplanes++;

-

-		// modify original_velocity so it parallels all of the clip planes

-		if ( GetMoveType() == MOVETYPE_WALK && (!(GetFlags() & FL_ONGROUND) || GetFriction()!=1) )	// relfect player velocity

-		{

-			for ( i = 0; i < numplanes; i++ )

-			{

-				if ( planes[i][2] > 0.7  )

-				{// floor or slope

-					PhysicsClipVelocity( original_velocity, planes[i], new_velocity, 1 );

-					VectorCopy( new_velocity, original_velocity );

-				}

-				else

-				{

-					PhysicsClipVelocity( original_velocity, planes[i], new_velocity, 1.0 + sv_bounce.GetFloat() * (1-GetFriction()) );

-				}

-			}

-

-			VectorCopy( new_velocity, vecAbsVelocity );

-			VectorCopy( new_velocity, original_velocity );

-		}

-		else

-		{

-			for (i=0 ; i<numplanes ; i++)

-			{

-				PhysicsClipVelocity (original_velocity, planes[i], new_velocity, 1);

-				for (j=0 ; j<numplanes ; j++)

-					if (j != i)

-					{

-						if (DotProduct (new_velocity, planes[j]) < 0)

-							break;	// not ok

-					}

-				if (j == numplanes)

-					break;

-			}

-			

-			if (i != numplanes)

-			{	

-				// go along this plane

-				VectorCopy (new_velocity, vecAbsVelocity);

-			}

-			else

-			{	

-				// go along the crease

-				if (numplanes != 2)

-				{

-	//				Msg( "clip velocity, numplanes == %i\n",numplanes);

-					SetAbsVelocity( vecAbsVelocity );

-					return blocked;

-				}

-				CrossProduct (planes[0], planes[1], dir);

-				d = DotProduct (dir, vecAbsVelocity);

-				VectorScale (dir, d, vecAbsVelocity);

-			}

-

-			//

-			// if original velocity is against the original velocity, stop dead

-			// to avoid tiny oscillations in sloping corners

-			//

-			if (DotProduct (vecAbsVelocity, primal_velocity) <= 0)

-			{

-				SetAbsVelocity(vec3_origin);

-				return blocked;

-			}

-		}

-	}

-

-	SetAbsVelocity( vecAbsVelocity );

-	return blocked;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Applies 1/2 gravity to falling movetype step objects

-//			Simulation should be done assuming average velocity over the time 

-//			interval.  Since that would effect a lot of code, and since most of 

-//			that code is going away, it's easier to just add in the average effect 

-//			of gravity on the velocity over the interval at the beginning of similation, 

-//			then add it in again at the end of simulation so that the final velocity is

-//			correct for the entire interval.

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsAddHalfGravity( float timestep )

-{

-	VPROF("CBaseEntity::PhysicsAddHalfGravity");

-	float	ent_gravity;

-

-	if ( GetGravity() )

-	{

-		ent_gravity = GetGravity();

-	}

-	else

-	{

-		ent_gravity = 1.0;

-	}

-

-	// Add 1/2 of the total gravitational effects over this timestep

-	Vector vecAbsVelocity = GetAbsVelocity();

-	vecAbsVelocity[2] -= ( 0.5 * ent_gravity * GetCurrentGravity() * timestep );

-	vecAbsVelocity[2] += GetBaseVelocity()[2] * gpGlobals->frametime;

-	SetAbsVelocity( vecAbsVelocity );

-

-	Vector vecNewBaseVelocity = GetBaseVelocity();

-	vecNewBaseVelocity[2] = 0;

-	SetBaseVelocity( vecNewBaseVelocity );

-	

-	// Bound velocity

-	PhysicsCheckVelocity();

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Does not change the entities velocity at all

-// Input  : push - 

-// Output : trace_t

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsPushEntity( const Vector& push, trace_t *pTrace )

-{

-	VPROF("CBaseEntity::PhysicsPushEntity");

-

-	if ( GetMoveParent() )

-	{

-		Warning( "pushing entity (%s) that has parent (%s)!\n", GetDebugName(), GetMoveParent()->GetDebugName() );

-		Assert(0);

-	}

-

-	// NOTE: absorigin and origin must be equal because there is no moveparent

-	Vector prevOrigin;

-	VectorCopy( GetAbsOrigin(), prevOrigin );

-

-	::PhysicsCheckSweep( this, prevOrigin, push, pTrace );

-

-	if ( pTrace->fraction )

-	{

-		SetAbsOrigin( pTrace->endpos );

-

-		// FIXME(ywb):  Should we try to enable this here

-		// WakeRestingObjects();

-	}

-

-	// Passing in the previous abs origin here will cause the relinker

-	// to test the swept ray from previous to current location for trigger intersections

-	PhysicsTouchTriggers( &prevOrigin );

-

-	if ( pTrace->m_pEnt )

-	{

-		PhysicsImpact( pTrace->m_pEnt, *pTrace );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:  See if entity is inside another entity, if so, returns true if so, fills in *ppEntity if ppEntity is not NULL

-// Input  : **ppEntity - optional return pointer to entity we are inside of

-// Output : Returns true on success, false on failure.

-//-----------------------------------------------------------------------------

-bool CBaseEntity::PhysicsTestEntityPosition( CBaseEntity **ppEntity /*=NULL*/ )

-{

-	VPROF("CBaseEntity::PhysicsTestEntityPosition");

-

-	trace_t	trace;

-	

-	unsigned int mask = PhysicsSolidMaskForEntity();

-

-	Physics_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), mask, &trace );

-	

-	if ( trace.startsolid )

-	{

-		if ( ppEntity )

-		{

-			*ppEntity = trace.m_pEnt;

-		}

-		return true;

-	}

-		

-	return false;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-CBaseEntity *CBaseEntity::PhysicsPushMove( float movetime )

-{

-	VPROF("CBaseEntity::PhysicsPushMove");

-

-	// If this entity isn't moving, just update the time.

-	IncrementLocalTime( movetime );

-

-	if ( GetLocalVelocity() == vec3_origin )

-	{

-		return NULL;

-	}

-

-	// Now check that the entire hierarchy can rotate into the new location

-	CBaseEntity *pBlocker = g_pPushedEntities->PerformLinearPush( this, movetime );

-	if ( pBlocker )

-	{

-		IncrementLocalTime( -movetime );

-	}

-	return pBlocker;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Tries to rotate, returns success or failure

-// Input  : movetime - 

-// Output : bool

-//-----------------------------------------------------------------------------

-CBaseEntity *CBaseEntity::PhysicsPushRotate( float movetime )

-{

-	VPROF("CBaseEntity::PhysicsPushRotate");

-

-	IncrementLocalTime( movetime );

-

-	// Not rotating

-	if ( GetLocalAngularVelocity() == vec3_angle )

-	{

-		return NULL;

-	}

-

-	// Now check that the entire hierarchy can rotate into the new location

-	CBaseEntity *pBlocker = g_pPushedEntities->PerformRotatePush( this, movetime );

-	if ( pBlocker )

-	{

-		IncrementLocalTime( -movetime );

-	}

-

-	return pBlocker;

-}

-

-

-//-----------------------------------------------------------------------------

-// Block of icky shared code from PhysicsParent + PhysicsPusher

-//-----------------------------------------------------------------------------

-void CBaseEntity::PerformPush( float movetime )

-{

-	VPROF("CBaseEntity::PerformPush");

-	// NOTE: Use handle index because the previous blocker could have been deleted

-	int hPrevBlocker = m_pBlocker.ToInt();

-	CBaseEntity *pBlocker;

-	g_pPushedEntities->BeginPush( this );

-	if (movetime > 0)

-	{

-		if ( GetLocalAngularVelocity() != vec3_angle )

-		{

-			if ( GetLocalVelocity() != vec3_origin )

-			{

-				// NOTE: Both PhysicsPushRotate + PhysicsPushMove

-				// will attempt to advance local time. Choose the one that's

-				// the greater of the two from push + move

-

-				// FIXME: Should we really be doing them both simultaneously??

-				// FIXME: Choose the *greater* of the two?!? That's strange...

-				float flInitialLocalTime = m_flLocalTime;

-

-				// moving and rotating, so rotate first, then move

-				pBlocker = PhysicsPushRotate( movetime );

-				if ( !pBlocker )

-				{

-					float flRotateLocalTime = m_flLocalTime;

-

-					// Reset the local time to what it was before we rotated

-					m_flLocalTime = flInitialLocalTime;

-					pBlocker = PhysicsPushMove( movetime );

-					if ( m_flLocalTime < flRotateLocalTime )

-					{

-						m_flLocalTime = flRotateLocalTime;

-					}

-				}

-			}

-			else

-			{

-				// only rotating

-				pBlocker = PhysicsPushRotate( movetime );

-			}

-		}

-		else

-		{

-			// only moving

-			pBlocker = PhysicsPushMove( movetime );

-		}

-

-		m_pBlocker = pBlocker;

-		if (m_pBlocker.ToInt() != hPrevBlocker)

-		{

-			if (hPrevBlocker != INVALID_EHANDLE_INDEX)

-			{

-				EndBlocked();

-			}

-			if (m_pBlocker)

-			{

-				StartBlocked( pBlocker );

-			}

-		}

-		if (m_pBlocker)

-		{

-			Blocked( m_pBlocker );

-		}

-

-		// NOTE NOTE: This is here for brutal reasons.

-		// For MOVETYPE_PUSH objects with VPhysics shadow objects, the move done time

-		// is handled by CBaseEntity::VPhyicsUpdatePusher, which only gets called if

-		// the physics system thinks the entity is awake. That will happen if the

-		// shadow gets updated, but the push code above doesn't update unless the

-		// move is successful or non-zero. So we must make sure it's awake

-		if ( VPhysicsGetObject() )

-		{

-			VPhysicsGetObject()->Wake();

-		}

-	}

-

-	// move done is handled by physics if it has any

-	if ( VPhysicsGetObject() )

-	{

-		// store the list of moved entities for later

-		// if you actually did an unblocked push that moved entities, and you're using physics (which may block later)

-		if ( movetime > 0 && !m_pBlocker && GetSolid() == SOLID_VPHYSICS && g_pPushedEntities->CountMovedEntities() > 0 )

-		{

-			// UNDONE: Any reason to want to call this twice before physics runs?

-			// If so, maybe just append to the list?

-			Assert( !GetDataObject( PHYSICSPUSHLIST ) );

-			physicspushlist_t *pList = (physicspushlist_t *)CreateDataObject( PHYSICSPUSHLIST );

-			if ( pList )

-			{

-				g_pPushedEntities->StoreMovedEntities( *pList );

-			}

-		}

-	}

-	else

-	{

-		if ( m_flMoveDoneTime <= m_flLocalTime && m_flMoveDoneTime > 0 )

-		{

-			SetMoveDoneTime( -1 );

-			MoveDone();

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: UNDONE: This is only different from PhysicsParent because of the callback to PhysicsVelocity()

-// Can we support that callback in push objects as well?

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsPusher( void )

-{

-	VPROF("CBaseEntity::PhysicsPusher");

-

-	// regular thinking

-	if ( !PhysicsRunThink() )

-		return;

-

-	m_flVPhysicsUpdateLocalTime = m_flLocalTime;

-

-	float movetime = GetMoveDoneTime();

-	if (movetime > gpGlobals->frametime)

-	{

-		movetime = gpGlobals->frametime;

-	}

-

-	PerformPush( movetime );

-}

-

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Non moving objects can only think

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsNone( void )

-{

-	VPROF("CBaseEntity::PhysicsNone");

-

-	// regular thinking

-	PhysicsRunThink();

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: A moving object that doesn't obey physics

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsNoclip( void )

-{

-	VPROF("CBaseEntity::PhysicsNoclip");

-

-	// regular thinking

-	if ( !PhysicsRunThink() )

-	{

-		return;

-	}

-	

-	// Apply angular velocity

-	SimulateAngles( gpGlobals->frametime );

-

-	Vector origin;

-	VectorMA( GetLocalOrigin(), gpGlobals->frametime, GetLocalVelocity(), origin );

-	SetLocalOrigin( origin );

-}

-

-

-void CBaseEntity::PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )

-{

-	// If you're going to use custom physics, you need to implement this!

-	Assert(0);

-}

-

-

-//-----------------------------------------------------------------------------

-// Allows entities to describe their own physics

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsCustom()

-{

-	VPROF("CBaseEntity::PhysicsCustom");

-	PhysicsCheckWater();

-

-	// regular thinking

-	if ( !PhysicsRunThink() )

-		return;

-

-	// Moving upward, off the ground, or  resting on a client/monster, remove FL_ONGROUND

-	if ( m_vecVelocity[2] > 0 || !GetGroundEntity() || !GetGroundEntity()->IsStandable() )

-	{

-		SetGroundEntity( NULL );

-	}

-

-	// NOTE: The entity must set the position, angles, velocity in its custom movement

-	Vector vecNewPosition = GetAbsOrigin();

-	Vector vecNewVelocity = GetAbsVelocity();

-	QAngle angNewAngles = GetAbsAngles();

-	QAngle angNewAngVelocity = GetLocalAngularVelocity();

-

-	PerformCustomPhysics( &vecNewPosition, &vecNewVelocity, &angNewAngles, &angNewAngVelocity );

-

-	// Store off all of the new state information...

-	SetAbsVelocity( vecNewVelocity );

-	SetAbsAngles( angNewAngles );

-	SetLocalAngularVelocity( angNewAngVelocity );

-

-	Vector move;

-	VectorSubtract( vecNewPosition, GetAbsOrigin(), move );

-

-	// move origin

-	trace_t trace;

-	PhysicsPushEntity( move, &trace );

-

-	PhysicsCheckVelocity();

-

-	if (trace.allsolid)

-	{	

-		// entity is trapped in another solid

-		// UNDONE: does this entity needs to be removed?

-		SetAbsVelocity(vec3_origin);

-		SetLocalAngularVelocity(vec3_angle);

-		return;

-	}

-	

-	if (IsEdictFree())

-		return;

-

-	// check for in water

-	PhysicsCheckWaterTransition();

-}

-

-bool g_bTestMoveTypeStepSimulation = true;

-ConVar sv_teststepsimulation( "sv_teststepsimulation", "1", 0 );

-

-//-----------------------------------------------------------------------------

-// Purpose: Until we remove the above cvar, we need to have the entities able

-//  to dynamically deal with changing their simulation stuff here.

-//-----------------------------------------------------------------------------

-void CBaseEntity::CheckStepSimulationChanged()

-{

-	if ( g_bTestMoveTypeStepSimulation != IsSimulatedEveryTick() )

-	{

-		SetSimulatedEveryTick( g_bTestMoveTypeStepSimulation );

-	}

-

-	bool hadobject = HasDataObjectType( STEPSIMULATION );

-

-	if ( g_bTestMoveTypeStepSimulation )

-	{

-		if ( !hadobject )

-		{

-			CreateDataObject( STEPSIMULATION );

-		}

-	}

-	else

-	{

-		if ( hadobject )

-		{

-			DestroyDataObject( STEPSIMULATION );

-		}

-	}

-}

-

-

-#define STEP_TELPORTATION_VEL_SQ	( 4096.0f * 4096.0f )

-//-----------------------------------------------------------------------------

-// Purpose: Run regular think and latch off angle/origin changes so we can interpolate them on the server to fake simulation

-// Input  : *step - 

-//-----------------------------------------------------------------------------

-void CBaseEntity::StepSimulationThink( float dt )

-{

-	// See if we need to allocate, deallocate step simulation object

-	CheckStepSimulationChanged();

-

-	StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION );

-	if ( !step )

-	{

-		PhysicsStepRunTimestep( dt );

-

-		// Just call the think function directly

-		PhysicsRunThink( THINK_FIRE_BASE_ONLY );

-	}

-	else

-	{

-		// Assume that it's in use

-		step->m_bOriginActive = true;

-		step->m_bAnglesActive = true;

-

-		// Reset networked versions of origin and angles

-		step->m_nLastProcessTickCount = -1;

-		step->m_vecNetworkOrigin.Init();

-		step->m_angNetworkAngles.Init();

-

-		// Remember old old values

-		step->m_Previous2 = step->m_Previous;

-

-		// Remember old values

-		step->m_Previous.nTickCount = gpGlobals->tickcount;

-		step->m_Previous.vecOrigin = GetStepOrigin();

-		QAngle stepAngles = GetStepAngles();

-		AngleQuaternion( stepAngles, step->m_Previous.qRotation );

-

-		// Run simulation

-		PhysicsStepRunTimestep( dt );

-

-		// Call the actual think function...

-		PhysicsRunThink( THINK_FIRE_BASE_ONLY );

-

-		// do any local processing that's needed

-		if (GetBaseAnimating() != NULL)

-		{

-			GetBaseAnimating()->UpdateStepOrigin();

-		}

-

-		// Latch new values to see if external code modifies our position/orientation

-		step->m_Next.vecOrigin = GetStepOrigin();

-		stepAngles = GetStepAngles();

-		AngleQuaternion( stepAngles, step->m_Next.qRotation );

-		// Also store of non-Quaternion version for simple comparisons

-		step->m_angNextRotation = GetStepAngles();

-		step->m_Next.nTickCount = GetNextThinkTick();

-

-		// Hack:  Add a tick if we are simulating every other tick

-		if ( CBaseEntity::IsSimulatingOnAlternateTicks() )

-		{

-			++step->m_Next.nTickCount;

-		}

-

-		// Check for teleportation/snapping of the origin

-		if ( dt > 0.0f )

-		{

-			Vector deltaorigin = step->m_Next.vecOrigin - step->m_Previous.vecOrigin;

-			float velSq = deltaorigin.LengthSqr() / ( dt * dt );

-			if ( velSq >= STEP_TELPORTATION_VEL_SQ )

-			{

-				// Deactivate it due to large origin change

-				step->m_bOriginActive = false;

-				step->m_bAnglesActive = false;

-			}

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Monsters freefall when they don't have a ground entity, otherwise

-//   all movement is done with discrete steps.

-// This is also used for objects that have become still on the ground, but

-//  will fall if the floor is pulled out from under them.

-// JAY: Extended this to synchronize movement and thinking wherever possible.

-// This allows the client-side interpolation to interpolate animation and simulation

-// data at the same time.

-// UNDONE:	Remove all other cases from this loop - only use MOVETYPE_STEP to simulate

-//			entities that are currently animating/thinking.

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsStep()

-{

-	// EVIL HACK: Force these to appear as if they've changed!!!

-	// The underlying values don't actually change, but we need the network sendproxy on origin/angles

-	//  to get triggered, and that only happens if NetworkStateChanged() appears to have occured.

-	// Getting them for modify marks them as changed automagically.

-	m_vecOrigin.GetForModify();

-	m_angRotation.GetForModify();

-	

-	// HACK:  Make sure that the client latches the networked origin/orientation changes with the current server tick count

-	//  so that we don't get jittery interpolation.  All of this is necessary to mimic actual continuous simulation of the underlying

-	//  variables.

-	SetSimulationTime( gpGlobals->curtime );

-	

-	// Run all but the base think function

-	PhysicsRunThink( THINK_FIRE_ALL_BUT_BASE );

-

-	int thinktick = GetNextThinkTick();

-	float thinktime = thinktick * TICK_INTERVAL;

-

-	// Is the next think too far out, or non-existent?

-	// BUGBUG: Interpolation is going to look bad in here.  But it should only

-	// be for dead things - and those should be ragdolls (client-side sim) anyway.

-	// UNDONE: Remove this and assert?  Force MOVETYPE_STEP objs to become MOVETYPE_TOSS when

-	// they aren't thinking?

-	// UNDONE: this happens as the first frame for a bunch of things like dynamically created ents.

-	// can't remove until initial conditions are resolved

-	float deltaThink = thinktime - gpGlobals->curtime;

-	if ( thinktime <= 0 || deltaThink > 0.5 )

-	{

-		PhysicsStepRunTimestep( gpGlobals->frametime );

-		PhysicsCheckWaterTransition();

-		SetLastThink( -1, gpGlobals->curtime );

-		UpdatePhysicsShadowToCurrentPosition(gpGlobals->frametime);

-		PhysicsRelinkChildren(gpGlobals->frametime);

-		return;

-	}

-

-	Vector oldOrigin = GetAbsOrigin();

-

-	// Feed the position delta back from vphysics if enabled

-	bool updateFromVPhysics = npc_vphysics.GetBool();

-	if ( HasDataObjectType(VPHYSICSUPDATEAI) )

-	{

-		vphysicsupdateai_t *pUpdate = static_cast<vphysicsupdateai_t *>(GetDataObject( VPHYSICSUPDATEAI ));

-		if ( pUpdate->stopUpdateTime > gpGlobals->curtime )

-		{

-			updateFromVPhysics = true;

-		}

-		else

-		{

-			float maxAngular;

-			VPhysicsGetObject()->GetShadowController()->GetMaxSpeed( NULL, &maxAngular );

-			VPhysicsGetObject()->GetShadowController()->MaxSpeed( pUpdate->savedShadowControllerMaxSpeed, maxAngular );

-			DestroyDataObject(VPHYSICSUPDATEAI);

-		}

-	}

-

-	if ( updateFromVPhysics && VPhysicsGetObject() && !GetParent() )

-	{

-		Vector position;

-		VPhysicsGetObject()->GetShadowPosition( &position, NULL );

-		float delta = (GetAbsOrigin() - position).LengthSqr();

-		// for now, use a tolerance of 1 inch for these tests

-		if ( delta < 1 )

-		{

-			// physics is really close, check to see if my current position is valid.

-			// If so, ignore the physics result.

-			trace_t tr;

-			Physics_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), PhysicsSolidMaskForEntity(), &tr );

-			updateFromVPhysics = tr.startsolid;

-		}

-		if ( updateFromVPhysics )

-		{

-			SetAbsOrigin( position );

-			PhysicsTouchTriggers();

-		}

-		//NDebugOverlay::Box( position, WorldAlignMins(), WorldAlignMaxs(), 255, 255, 0, 0, 0.0 );

-	}

-

-	// not going to think, don't run game physics either

-	if ( thinktick > gpGlobals->tickcount )

-		return;

-	

-	// Don't let things stay in the past.

-	//  it is possible to start that way

-	//  by a trigger with a local time.

-	if ( thinktime < gpGlobals->curtime )

-	{

-		thinktime = gpGlobals->curtime;	

-	}

-

-	// simulate over the timestep

-	float dt = thinktime - GetLastThink();

-

-	// Now run step simulator

-	StepSimulationThink( dt );

-

-	PhysicsCheckWaterTransition();

-

-	if ( VPhysicsGetObject() )

-	{

-		if ( !VectorCompare( oldOrigin, GetAbsOrigin() ) )

-		{

-			VPhysicsGetObject()->UpdateShadow( GetAbsOrigin(), vec3_angle, (GetFlags() & FL_FLY) ? true : false, dt );

-		}

-	}

-	PhysicsRelinkChildren(dt);

-}

-

-

-void UTIL_TraceLineFilterEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd, 

-					   unsigned int mask, const int nCollisionGroup, trace_t *ptr );

-

-// Check to see what (if anything) this MOVETYPE_STEP entity is standing on

-void CBaseEntity::PhysicsStepRecheckGround()

-{

-	unsigned int mask = PhysicsSolidMaskForEntity();

-	// determine if it's on solid ground at all

-	Vector	mins, maxs, point;

-	int		x, y;

-	trace_t trace;

-	

-	VectorAdd (GetAbsOrigin(), WorldAlignMins(), mins);

-	VectorAdd (GetAbsOrigin(), WorldAlignMaxs(), maxs);

-	point[2] = mins[2] - 1;

-	for	(x=0 ; x<=1 ; x++)

-	{

-		for	(y=0 ; y<=1 ; y++)

-		{

-			point[0] = x ? maxs[0] : mins[0];

-			point[1] = y ? maxs[1] : mins[1];

-

-			ICollideable *pCollision = GetCollideable();

-

-			if ( pCollision && IsNPC() )

-			{

-				UTIL_TraceLineFilterEntity( this, point, point, mask, COLLISION_GROUP_NONE, &trace );

-			}

-			else

-			{

-				UTIL_TraceLine( point, point, mask, this, COLLISION_GROUP_NONE, &trace );

-			}

-

-			if ( trace.startsolid )

-			{

-				SetGroundEntity( trace.m_pEnt );

-				return;

-			}

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : timestep - 

-//-----------------------------------------------------------------------------

-void CBaseEntity::PhysicsStepRunTimestep( float timestep )

-{

-	bool	wasonground;

-	bool	inwater;

-	bool	hitsound = false;

-	float	speed, newspeed, control;

-	float	friction;

-

-	PhysicsCheckVelocity();

-

-	wasonground = ( GetFlags() & FL_ONGROUND ) ? true : false;

-

-	// add gravity except:

-	//   flying monsters

-	//   swimming monsters who are in the water

-	inwater = PhysicsCheckWater();

-

-	bool isfalling = false;

-

-	if ( !wasonground )

-	{

-		if ( !( GetFlags() & FL_FLY ) )

-		{

-			if ( !( ( GetFlags() & FL_SWIM ) && ( GetWaterLevel() > 0 ) ) )

-			{

-				if ( GetAbsVelocity()[2] < ( GetCurrentGravity() * -0.1 ) )

-				{

-					hitsound = true;

-				}

-

-				if ( !inwater )

-				{

-					PhysicsAddHalfGravity( timestep );

-					isfalling = true;

-				}

-			}

-		}

-	}

-

-	if ( !(GetFlags() & FL_STEPMOVEMENT) &&

-		(!VectorCompare(GetAbsVelocity(), vec3_origin) || 

-		 !VectorCompare(GetBaseVelocity(), vec3_origin)))

-	{

-		Vector vecAbsVelocity = GetAbsVelocity();

-

-		SetGroundEntity( NULL );

-		// apply friction

-		// let dead monsters who aren't completely onground slide

-		if ( wasonground )

-		{

-			speed = VectorLength( vecAbsVelocity );

-			if (speed)

-			{

-				friction = sv_friction.GetFloat() * GetFriction();

-

-				control = speed < sv_stopspeed.GetFloat() ? sv_stopspeed.GetFloat() : speed;

-				newspeed = speed - timestep*control*friction;

-

-				if (newspeed < 0)

-					newspeed = 0;

-				newspeed /= speed;

-

-				vecAbsVelocity[0] *= newspeed;

-				vecAbsVelocity[1] *= newspeed;

-			}

-		}

-

-		vecAbsVelocity += GetBaseVelocity();

-		SetAbsVelocity( vecAbsVelocity );

-

-		// Apply angular velocity

-		SimulateAngles( timestep );

-

-		PhysicsCheckVelocity();

-

-		PhysicsTryMove( timestep, NULL );

-

-		PhysicsCheckVelocity();

-

-		vecAbsVelocity = GetAbsVelocity();

-		vecAbsVelocity -= GetBaseVelocity();

-		SetAbsVelocity( vecAbsVelocity );

-

-		PhysicsCheckVelocity();

-

-		if ( !(GetFlags() & FL_ONGROUND) )

-		{

-			PhysicsStepRecheckGround();

-		}

-

-		PhysicsTouchTriggers();

-	}

-

-	if (!( GetFlags() & FL_ONGROUND ) && isfalling)

-	{

-		PhysicsAddHalfGravity( timestep );

-	}

-}

-

-// After this long, if a player isn't updating, then return it's projectiles to server control

-#define PLAYER_PACKETS_STOPPED_SO_RETURN_TO_PHYSICS_TIME 1.0f

-

-void Physics_SimulateEntity( CBaseEntity *pEntity )

-{

-	VPROF( ( !vprof_scope_entity_gamephys.GetBool() ) ? 

-			"Physics_SimulateEntity" : 

-			EntityFactoryDictionary()->GetCannonicalName( pEntity->GetClassname() ) );

-

-	if ( pEntity->edict() )

-	{

-#if !defined( NO_ENTITY_PREDICTION )

-		// Player drives simulation of this entity

-		if ( pEntity->IsPlayerSimulated() )

-		{

-			// If the player is gone, dropped, crashed, then return

-			//  control to the game code.

-			CBasePlayer *simulatingPlayer = pEntity->GetSimulatingPlayer();

-			if ( simulatingPlayer &&

-				( simulatingPlayer->GetTimeBase() > gpGlobals->curtime - PLAYER_PACKETS_STOPPED_SO_RETURN_TO_PHYSICS_TIME ) )

-			{

-				// Okay, the guy is still around

-				return;

-			}

-

-			pEntity->UnsetPlayerSimulated();

-		}

-#endif

-

-		MDLCACHE_CRITICAL_SECTION();

-

-#if !defined( NO_ENTITY_PREDICTION )

-		// If an object was at one point player simulated, but had that status revoked (as just

-		//  above when no packets have arrived in a while ), then we still will assume that the

-		//  owner/player will be predicting the entity locally (even if the game is playing like butt)

-		//  and so we won't spam that player with additional network data such as effects/sounds 

-		//  that are theoretically being predicted by the player anyway.

-		if ( pEntity->m_PredictableID->IsActive() )

-		{

-			CBasePlayer *playerowner = ToBasePlayer( pEntity->GetOwnerEntity() );

-			if ( playerowner )

-			{

-				CBasePlayer *pl = ToBasePlayer( UTIL_PlayerByIndex( pEntity->m_PredictableID->GetPlayer() + 1 ) );

-				// Is the player who created it still the owner?

-				if ( pl == playerowner )

-				{

-					// Set up to suppress sending events to owner player

-					if ( pl->IsPredictingWeapons() )

-					{

-						IPredictionSystem::SuppressHostEvents( playerowner );

-					}

-				}

-			}	

-			{

-				VPROF( ( !vprof_scope_entity_gamephys.GetBool() ) ? 

-						"pEntity->PhysicsSimulate" : 

-						EntityFactoryDictionary()->GetCannonicalName( pEntity->GetClassname() ) );

-

-				// Run entity physics

-				pEntity->PhysicsSimulate();

-			}

-

-			// Restore suppression filter

-			IPredictionSystem::SuppressHostEvents( NULL );

-		}

-		else

-#endif

-		{

-			// Run entity physics

-			pEntity->PhysicsSimulate();

-		}

-	}

-	else

-	{

-		pEntity->PhysicsRunThink();

-	}

-}

-//-----------------------------------------------------------------------------

-// Purpose: Runs the main physics simulation loop against all entities ( except players )

-//-----------------------------------------------------------------------------

-void Physics_RunThinkFunctions( bool simulating )

-{

-	VPROF( "Physics_RunThinkFunctions");

-

-	g_bTestMoveTypeStepSimulation = sv_teststepsimulation.GetBool();

-

-	float starttime = gpGlobals->curtime;

-	// clear all entites freed outside of this loop

-	gEntList.CleanupDeleteList();

-

-	if ( !simulating )

-	{

-		// only simulate players

-		for ( int i = 1; i <= gpGlobals->maxClients; i++ )

-		{

-			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );

-			if ( pPlayer )

-			{

-				// Always reset clock to real sv.time

-				gpGlobals->curtime = starttime;

-				// Force usercmd processing even though gpGlobals->tickcount isn't incrementing

-				pPlayer->ForceSimulation();

-				Physics_SimulateEntity( pPlayer );

-			}

-		}

-	}

-	else

-	{

-		UTIL_DisableRemoveImmediate();

-		int listMax = SimThink_ListCount();

-		listMax = MAX(listMax,1);

-		CBaseEntity **list = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * listMax );

-		// iterate through all entities and have them think or simulate

-		

-		// UNDONE: This has problems with UTIL_RemoveImmediate() (now disabled during this loop).  

-		// Do we really need UTIL_RemoveImmediate()?

-		int count = SimThink_ListCopy( list, listMax );

-

-		//DevMsg(1, "Count: %d\n", count );

-		for ( int i = 0; i < count; i++ )

-		{

-			if ( !list[i] )

-				continue;

-			// Always reset clock to real sv.time

-			gpGlobals->curtime = starttime;

-			Physics_SimulateEntity( list[i] );

-		}

-

-		stackfree( list );

-		UTIL_EnableRemoveImmediate();

-	}

-

-	gpGlobals->curtime = starttime;

-}

-

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Physics simulation for non-havok/ipion objects
+//
+// $NoKeywords: $
+//=============================================================================//
+
+
+#include "cbase.h"
+#ifdef _WIN32
+#include "typeinfo.h"
+// BUGBUG: typeinfo stomps some of the warning settings (in yvals.h)
+#pragma warning(disable:4244)
+#elif POSIX
+#include <typeinfo>
+#else
+#error "need typeinfo defined"
+#endif
+
+#include "player.h"
+#include "ai_basenpc.h"
+#include "gamerules.h"
+#include "vphysics_interface.h"
+#include "mempool.h"
+#include "entitylist.h"
+#include "engine/IEngineSound.h"
+#include "datacache/imdlcache.h"
+#include "ispatialpartition.h"
+#include "tier0/vprof.h"
+#include "movevars_shared.h"
+#include "hierarchy.h"
+#include "trains.h"
+#include "vphysicsupdateai.h"
+#include "tier0/vcrmode.h"
+#include "pushentity.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern ConVar think_limit;
+#ifdef _XBOX
+ConVar vprof_think_limit( "vprof_think_limit", "0" );
+#endif
+
+ConVar vprof_scope_entity_thinks( "vprof_scope_entity_thinks", "0" );
+ConVar vprof_scope_entity_gamephys( "vprof_scope_entity_gamephys", "0" );
+
+ConVar	npc_vphysics	( "npc_vphysics","0");
+//-----------------------------------------------------------------------------
+// helper method for trace hull as used by physics...
+//-----------------------------------------------------------------------------
+static void Physics_TraceEntity( CBaseEntity* pBaseEntity, const Vector &vecAbsStart,
+	const Vector &vecAbsEnd, unsigned int mask, trace_t *ptr )
+{
+	// FIXME: I really am not sure the best way of doing this
+	// The TraceHull code below for shots will make sure the object passes
+	// through shields which do not block that damage type. It will also 
+	// send messages to the shields that they've been hit.
+	if (pBaseEntity->GetDamageType() != DMG_GENERIC)
+	{
+		GameRules()->WeaponTraceEntity( pBaseEntity, vecAbsStart, vecAbsEnd, mask, ptr );
+	}
+	else
+	{
+		UTIL_TraceEntity( pBaseEntity, vecAbsStart, vecAbsEnd, mask, ptr );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Does not change the entities velocity at all
+// Input  : push - 
+// Output : trace_t
+//-----------------------------------------------------------------------------
+static void PhysicsCheckSweep( CBaseEntity *pEntity, const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace )
+{
+	unsigned int mask = pEntity->PhysicsSolidMaskForEntity();
+
+	Vector vecAbsEnd;
+	VectorAdd( vecAbsStart, vecAbsDelta, vecAbsEnd );
+
+	// Set collision type
+	if ( !pEntity->IsSolid() || pEntity->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS) )
+	{
+		if ( pEntity->GetMoveParent() )
+		{
+			UTIL_ClearTrace( *pTrace );
+			return;
+		}
+
+		// don't collide with monsters
+		mask &= ~CONTENTS_MONSTER;
+	}
+
+	Physics_TraceEntity( pEntity, vecAbsStart, vecAbsEnd, mask, pTrace );
+}
+
+CPhysicsPushedEntities s_PushedEntities;
+#ifndef TF_DLL
+CPhysicsPushedEntities *g_pPushedEntities = &s_PushedEntities;
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CPhysicsPushedEntities::CPhysicsPushedEntities( void ) : m_rgPusher(8, 8), m_rgMoved(32, 32)
+{
+	m_flMoveTime = -1.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Store off entity and copy original origin to temporary array
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::AddEntity( CBaseEntity *ent )
+{
+	int i = m_rgMoved.AddToTail();
+	m_rgMoved[i].m_pEntity = ent;
+	m_rgMoved[i].m_vecStartAbsOrigin = ent->GetAbsOrigin();
+}
+
+
+//-----------------------------------------------------------------------------
+// Unlink + relink the pusher list so we can actually do the push
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::UnlinkPusherList( int *pPusherHandles )
+{
+	for ( int i = m_rgPusher.Count(); --i >= 0; )
+	{
+		pPusherHandles[i] = partition->HideElement( m_rgPusher[i].m_pEntity->CollisionProp()->GetPartitionHandle() );
+	}
+}
+
+void CPhysicsPushedEntities::RelinkPusherList( int *pPusherHandles )
+{
+	for ( int i = m_rgPusher.Count(); --i >= 0; )
+	{
+		partition->UnhideElement( m_rgPusher[i].m_pEntity->CollisionProp()->GetPartitionHandle(), pPusherHandles[i] );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute the direction to move the rotation blocker
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::ComputeRotationalPushDirection( CBaseEntity *pBlocker, const RotatingPushMove_t &rotPushMove, Vector *pMove, CBaseEntity *pRoot )
+{
+	// calculate destination position
+	// "start" is relative to the *root* pusher, world orientation
+	Vector start = pBlocker->CollisionProp()->GetCollisionOrigin();
+	if ( pRoot->GetSolid() == SOLID_VPHYSICS )
+	{
+		// HACKHACK: Use move dir to guess which corner of the box determines contact and rotate the box so
+		// that corner remains in the same local position.
+		// BUGBUG: This will break, but not as badly as the previous solution!!!
+		Vector vecAbsMins, vecAbsMaxs;
+		pBlocker->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
+		start.x = (pMove->x < 0) ? vecAbsMaxs.x : vecAbsMins.x;
+		start.y = (pMove->y < 0) ? vecAbsMaxs.y : vecAbsMins.y;
+		start.z = (pMove->z < 0) ? vecAbsMaxs.z : vecAbsMins.z;
+		
+		CBasePlayer *pPlayer = ToBasePlayer(pBlocker);
+		if ( pPlayer )
+		{
+			// notify the player physics code so it can use vphysics to keep players from getting stuck
+			pPlayer->SetPhysicsFlag( PFLAG_GAMEPHYSICS_ROTPUSH, true );
+		}
+	}
+
+	// org is pusher local coordinate of start
+	Vector local;
+	// transform starting point into local space
+	VectorITransform( start, rotPushMove.startLocalToWorld, local );
+	// rotate local org into world space at end of rotation
+	Vector end;
+	VectorTransform( local, rotPushMove.endLocalToWorld, end );
+
+	// move is the difference (in world space) that the move will push this object
+	VectorSubtract( end, start, *pMove );
+}
+
+class CTraceFilterPushFinal : public CTraceFilterSimple
+{
+	DECLARE_CLASS( CTraceFilterPushFinal, CTraceFilterSimple );
+
+public:
+	CTraceFilterPushFinal( CBaseEntity *pEntity, int nCollisionGroup ) 
+		: CTraceFilterSimple( pEntity, nCollisionGroup )
+	{
+	
+	}
+
+	bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
+	{
+		Assert( dynamic_cast<CBaseEntity*>(pHandleEntity) );
+		CBaseEntity *pTestEntity = static_cast<CBaseEntity*>(pHandleEntity);
+
+		// UNDONE: This should really filter to just the pushing entities
+		if ( pTestEntity->GetMoveType() == MOVETYPE_VPHYSICS && 
+			pTestEntity->VPhysicsGetObject() && pTestEntity->VPhysicsGetObject()->IsMoveable() )
+			return false;
+
+		return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
+	}
+
+};
+
+bool CPhysicsPushedEntities::IsPushedPositionValid( CBaseEntity *pBlocker )
+{
+	CTraceFilterPushFinal pushFilter(pBlocker, pBlocker->GetCollisionGroup() );
+
+	trace_t trace;
+	UTIL_TraceEntity( pBlocker, pBlocker->GetAbsOrigin(), pBlocker->GetAbsOrigin(), pBlocker->PhysicsSolidMaskForEntity(), &pushFilter, &trace );
+
+	return !trace.startsolid;
+}
+
+//-----------------------------------------------------------------------------
+// Speculatively checks to see if all entities in this list can be pushed
+//-----------------------------------------------------------------------------
+bool CPhysicsPushedEntities::SpeculativelyCheckPush( PhysicsPushedInfo_t &info, const Vector &vecAbsPush, bool bRotationalPush )
+{
+	CBaseEntity *pBlocker = info.m_pEntity;
+
+	// See if it's possible to move the entity, but disable all pushers in the hierarchy first
+	int *pPusherHandles = (int*)stackalloc( m_rgPusher.Count() * sizeof(int) );
+	UnlinkPusherList( pPusherHandles );
+	CTraceFilterPushMove pushFilter(pBlocker, pBlocker->GetCollisionGroup() );
+
+	Vector pushDestPosition = pBlocker->GetAbsOrigin() + vecAbsPush;
+	UTIL_TraceEntity( pBlocker, pBlocker->GetAbsOrigin(), pushDestPosition, 
+		pBlocker->PhysicsSolidMaskForEntity(), &pushFilter, &info.m_Trace );
+
+	RelinkPusherList(pPusherHandles);
+	info.m_bPusherIsGround = false;
+	if ( pBlocker->GetGroundEntity() && pBlocker->GetGroundEntity()->GetRootMoveParent() == m_rgPusher[0].m_pEntity )
+	{
+		info.m_bPusherIsGround = true;
+	}
+
+	bool bIsUnblockable = (m_bIsUnblockableByPlayer && (pBlocker->IsPlayer() || pBlocker->MyNPCPointer())) ? true : false;
+	if ( bIsUnblockable )
+	{
+		pBlocker->SetAbsOrigin( pushDestPosition );
+	}
+	else
+	{
+		// Move the blocker into its new position
+		if ( info.m_Trace.fraction )
+		{
+			pBlocker->SetAbsOrigin( info.m_Trace.endpos );
+		}
+
+		// We're not blocked if the blocker is point-sized or non-solid
+		if ( pBlocker->IsPointSized() || !pBlocker->IsSolid() || 
+			pBlocker->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
+		{
+			return true;
+		}
+
+		if ( (!bRotationalPush) && (info.m_Trace.fraction == 1.0) )
+		{
+			//Assert( pBlocker->PhysicsTestEntityPosition() == false );
+			if ( !IsPushedPositionValid(pBlocker) )
+			{
+				Warning("Interpenetrating entities! (%s and %s)\n",
+					pBlocker->GetClassname(), m_rgPusher[0].m_pEntity->GetClassname() );
+			}
+
+			return true;
+		}
+	}
+
+	// Check to see if we're still blocked by the pushers
+	// FIXME: If the trace fraction == 0 can we early out also?
+	info.m_bBlocked = !IsPushedPositionValid(pBlocker);
+
+	if ( !info.m_bBlocked )
+		return true;
+
+	// if the player is blocking the train try nudging him around to fix accumulated error
+	if ( bIsUnblockable )
+	{
+		Vector org = pBlocker->GetAbsOrigin();
+		for ( int checkCount = 0; checkCount < 4; checkCount++ )
+		{
+			Vector move;
+			MatrixGetColumn( m_rgPusher[0].m_pEntity->EntityToWorldTransform(), checkCount>>1, move );
+			
+			// alternate movements 1/2" in each direction
+			float factor = ( checkCount & 1 ) ? -0.5f : 0.5f;
+			pBlocker->SetAbsOrigin( org + move * factor );
+			info.m_bBlocked = !IsPushedPositionValid(pBlocker);
+			if ( !info.m_bBlocked )
+				return true;
+		}
+		pBlocker->SetAbsOrigin( pushDestPosition );
+
+#ifndef TF_DLL
+		DevMsg(1, "Ignoring player blocking train!\n");
+#endif
+		return true;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Speculatively checks to see if all entities in this list can be pushed
+//-----------------------------------------------------------------------------
+bool CPhysicsPushedEntities::SpeculativelyCheckRotPush( const RotatingPushMove_t &rotPushMove, CBaseEntity *pRoot )
+{
+	Vector vecAbsPush;
+	m_nBlocker = -1;
+	for (int i = m_rgMoved.Count(); --i >= 0; )
+	{
+		ComputeRotationalPushDirection( m_rgMoved[i].m_pEntity, rotPushMove, &vecAbsPush, pRoot );
+		if (!SpeculativelyCheckPush( m_rgMoved[i], vecAbsPush, true ))
+		{
+			m_nBlocker = i;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Speculatively checks to see if all entities in this list can be pushed
+//-----------------------------------------------------------------------------
+bool CPhysicsPushedEntities::SpeculativelyCheckLinearPush( const Vector &vecAbsPush )
+{
+	m_nBlocker = -1;
+	for (int i = m_rgMoved.Count(); --i >= 0; )
+	{
+		if (!SpeculativelyCheckPush( m_rgMoved[i], vecAbsPush, false ))
+		{
+			m_nBlocker = i;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Causes all entities in the list to touch triggers from their prev position
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::FinishPushers()
+{
+	// We succeeded! Now that we know the final location of all entities,
+	// touch triggers + update physics objects + do other fixup
+	for ( int i = m_rgPusher.Count(); --i >= 0; )
+	{
+		PhysicsPusherInfo_t &info = m_rgPusher[i];
+
+		// Cause touch functions to be called
+		// FIXME: Need to make moved entities not touch triggers until we know we're ok
+		// FIXME: it'd be better for the engine to just have a touch method
+		info.m_pEntity->PhysicsTouchTriggers( &info.m_vecStartAbsOrigin );
+
+		info.m_pEntity->UpdatePhysicsShadowToCurrentPosition( gpGlobals->frametime );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Causes all entities in the list to touch triggers from their prev position
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::FinishRotPushedEntity( CBaseEntity *pPushedEntity, const RotatingPushMove_t &rotPushMove )
+{
+	// Impart angular velocity of push onto pushed objects
+	if ( pPushedEntity->IsPlayer() )
+	{
+		QAngle angVel = pPushedEntity->GetLocalAngularVelocity();
+		angVel[1] = rotPushMove.amove[1];
+		pPushedEntity->SetLocalAngularVelocity(angVel);
+
+		// Look up associated client
+		CBasePlayer *player = ( CBasePlayer * )pPushedEntity;
+		player->pl.fixangle = FIXANGLE_RELATIVE;
+		// Because we can run multiple ticks per server frame, accumulate a total offset here instead of straight
+		//  setting it.  The engine will reset anglechange to 0 when the message is actually sent to the client
+		player->pl.anglechange += rotPushMove.amove;
+	}
+	else
+	{
+		QAngle angles = pPushedEntity->GetAbsAngles();
+		
+		// only rotate YAW with pushing.  Freely rotateable entities should either use VPHYSICS
+		// or be set up as children
+		angles.y += rotPushMove.amove.y;
+		pPushedEntity->SetAbsAngles( angles );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Causes all entities in the list to touch triggers from their prev position
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::FinishPush( bool bIsRotPush, const RotatingPushMove_t *pRotPushMove )
+{
+	FinishPushers();
+
+	for ( int i = m_rgMoved.Count(); --i >= 0; )
+	{
+		PhysicsPushedInfo_t &info = m_rgMoved[i];
+		CBaseEntity *pPushedEntity = info.m_pEntity;
+
+		// Cause touch functions to be called
+		// FIXME: it'd be better for the engine to just have a touch method
+		info.m_pEntity->PhysicsTouchTriggers( &info.m_vecStartAbsOrigin );
+		info.m_pEntity->UpdatePhysicsShadowToCurrentPosition( gpGlobals->frametime );
+		CAI_BaseNPC *pNPC = info.m_pEntity->MyNPCPointer();
+		if ( info.m_bPusherIsGround && pNPC )
+		{
+			pNPC->NotifyPushMove();
+		}
+
+
+		// Register physics impacts...
+		if (info.m_Trace.m_pEnt)
+		{
+			pPushedEntity->PhysicsImpact( info.m_Trace.m_pEnt, info.m_Trace );
+		}
+
+		if (bIsRotPush)
+		{
+			FinishRotPushedEntity( pPushedEntity, *pRotPushMove );
+		}
+	}
+}
+
+// save initial state when beginning a push sequence
+void CPhysicsPushedEntities::BeginPush( CBaseEntity *pRoot )
+{
+	m_rgMoved.RemoveAll();
+	m_rgPusher.RemoveAll();
+
+	m_rootPusherStartLocalOrigin = pRoot->GetLocalOrigin();
+	m_rootPusherStartLocalAngles = pRoot->GetLocalAngles();
+	m_rootPusherStartLocaltime = pRoot->GetLocalTime();
+}
+
+// store off a list of what has changed - so vphysicsUpdate can undo this if the object gets blocked
+void CPhysicsPushedEntities::StoreMovedEntities( physicspushlist_t &list )
+{
+	list.localMoveTime = m_rootPusherStartLocaltime;
+	list.localOrigin = m_rootPusherStartLocalOrigin;
+	list.localAngles = m_rootPusherStartLocalAngles;
+	list.pushedCount = CountMovedEntities();
+	Assert(list.pushedCount < ARRAYSIZE(list.pushedEnts));
+	if ( list.pushedCount > ARRAYSIZE(list.pushedEnts) )
+	{
+		list.pushedCount = ARRAYSIZE(list.pushedEnts);
+	}
+	for ( int i = 0; i < list.pushedCount; i++ )
+	{
+		list.pushedEnts[i] = m_rgMoved[i].m_pEntity;
+		list.pushVec[i] = m_rgMoved[i].m_pEntity->GetAbsOrigin() - m_rgMoved[i].m_vecStartAbsOrigin;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Registers a blockage
+//-----------------------------------------------------------------------------
+CBaseEntity *CPhysicsPushedEntities::RegisterBlockage()
+{
+	Assert(	m_nBlocker >= 0 );
+
+	// Generate a PhysicsImpact against the blocker...
+	PhysicsPushedInfo_t &info = m_rgMoved[m_nBlocker];
+	if ( info.m_Trace.m_pEnt )
+	{
+		info.m_pEntity->PhysicsImpact( info.m_Trace.m_pEnt, info.m_Trace );
+	}
+
+	// This is the dude 
+	return info.m_pEntity;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Restore entities that might have been moved
+// Input  : fromrotation - if the move is from a rotation, then angular move must also be reverted
+//			*amove - 
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::RestoreEntities( )
+{
+	// Reset all of the pushed entities to get them back into place also
+	for ( int i = m_rgMoved.Count(); --i >= 0; )
+	{
+		m_rgMoved[ i ].m_pEntity->SetAbsOrigin( m_rgMoved[ i ].m_vecStartAbsOrigin );
+	}
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: This is a trace filter that only hits an exclusive list of entities
+//-----------------------------------------------------------------------------
+class CTraceFilterAgainstEntityList : public ITraceFilter
+{
+public:
+	virtual bool ShouldHitEntity( IHandleEntity *pEntity, int contentsMask )
+	{
+		for ( int i = m_entityList.Count()-1; i >= 0; --i )
+		{
+			if ( m_entityList[i] == pEntity )
+				return true;
+		}
+
+		return false;
+	}
+
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_ENTITIES_ONLY;
+	}
+
+	void AddEntityToHit( IHandleEntity *pEntity )
+	{
+		m_entityList.AddToTail(pEntity);
+	}
+
+	CUtlVector<IHandleEntity *>	m_entityList;
+};
+
+//-----------------------------------------------------------------------------
+// Generates a list of potential blocking entities
+//-----------------------------------------------------------------------------
+class CPushBlockerEnum : public IPartitionEnumerator
+{
+public:
+	CPushBlockerEnum( CPhysicsPushedEntities *pPushedEntities ) : m_pPushedEntities(pPushedEntities)
+	{
+		// All elements are part of the same hierarchy, so they all have
+		// the same root, so it doesn't matter which one we grab
+		m_pRootHighestParent = m_pPushedEntities->m_rgPusher[0].m_pEntity->GetRootMoveParent();
+		++s_nEnumCount;
+
+		m_collisionGroupCount = 0;
+		for ( int i = m_pPushedEntities->m_rgPusher.Count(); --i >= 0; )
+		{
+			if ( !m_pPushedEntities->m_rgPusher[i].m_pEntity->IsSolid() )
+				continue;
+
+			m_pushersOnly.AddEntityToHit( m_pPushedEntities->m_rgPusher[i].m_pEntity );
+			int collisionGroup = m_pPushedEntities->m_rgPusher[i].m_pEntity->GetCollisionGroup();
+			AddCollisionGroup(collisionGroup);
+		}
+
+	}
+
+	virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity )
+	{
+		CBaseEntity *pCheck = GetPushableEntity( pHandleEntity );
+		if ( !pCheck )
+			return ITERATION_CONTINUE;
+
+		// Mark it as seen
+		pCheck->m_nPushEnumCount = s_nEnumCount;
+		m_pPushedEntities->AddEntity( pCheck );
+
+		return ITERATION_CONTINUE;
+	}
+
+private:
+
+	inline void AddCollisionGroup(int collisionGroup)
+	{
+		for ( int i = 0; i < m_collisionGroupCount; i++ )
+		{
+			if ( m_collisionGroups[i] == collisionGroup )
+				return;
+		}
+		if ( m_collisionGroupCount < ARRAYSIZE(m_collisionGroups) )
+		{
+			m_collisionGroups[m_collisionGroupCount] = collisionGroup;
+			m_collisionGroupCount++;
+		}
+	}
+
+	bool IsStandingOnPusher( CBaseEntity *pCheck )
+	{
+		CBaseEntity *pGroundEnt = pCheck->GetGroundEntity();
+		if ( pCheck->GetFlags() & FL_ONGROUND || pGroundEnt )
+		{
+			for ( int i = m_pPushedEntities->m_rgPusher.Count(); --i >= 0; )
+			{
+				if (m_pPushedEntities->m_rgPusher[i].m_pEntity == pGroundEnt)
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	bool IntersectsPushers( CBaseEntity *pTest )
+	{
+		trace_t tr;
+
+		ICollideable *pCollision = pTest->GetCollideable();
+		enginetrace->SweepCollideable( pCollision, pTest->GetAbsOrigin(), pTest->GetAbsOrigin(), pCollision->GetCollisionAngles(), 
+			pTest->PhysicsSolidMaskForEntity(), &m_pushersOnly, &tr );
+
+		return tr.startsolid;
+	}
+
+	CBaseEntity *GetPushableEntity( IHandleEntity *pHandleEntity )
+	{
+		CBaseEntity *pCheck = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
+		if ( !pCheck )
+			return NULL;
+
+		// Don't bother if we've already seen this one...
+		if (pCheck->m_nPushEnumCount == s_nEnumCount)
+			return NULL;
+
+		if ( !pCheck->IsSolid() )
+			return NULL;
+
+		if ( pCheck->GetMoveType() == MOVETYPE_PUSH || 
+			 pCheck->GetMoveType() == MOVETYPE_NONE || 
+			 pCheck->GetMoveType() == MOVETYPE_VPHYSICS ||
+			 pCheck->GetMoveType() == MOVETYPE_NOCLIP )
+		{
+			return NULL;
+		}
+
+		bool bCollide = false;
+		for ( int i = 0; i < m_collisionGroupCount; i++ )
+		{
+			if ( g_pGameRules->ShouldCollide( pCheck->GetCollisionGroup(), m_collisionGroups[i] ) )
+			{
+				bCollide = true;
+				break;
+			}
+		}
+		if ( !bCollide )
+			return NULL;
+		// We're not pushing stuff we're hierarchically attached to
+		CBaseEntity *pCheckHighestParent = pCheck->GetRootMoveParent();
+		if (pCheckHighestParent == m_pRootHighestParent)
+			return NULL;
+
+		// If we're standing on the pusher or any rigidly attached child
+		// of the pusher, we don't need to bother checking for interpenetration
+		if ( !IsStandingOnPusher(pCheck) )
+		{
+			// Our surrounding boxes are touching. But we may well not be colliding....
+			// see if the ent's bbox is inside the pusher's final position
+			if ( !IntersectsPushers( pCheck ) )
+				return NULL;
+		}
+
+		// NOTE: This is pretty tricky here. If a rigidly attached child comes into
+		// contact with a pusher, we *cannot* push the child. Instead, we must push
+		// the highest parent of that child.
+		return pCheckHighestParent;
+	}
+
+private:
+	static int s_nEnumCount;
+	CPhysicsPushedEntities *m_pPushedEntities;
+	CBaseEntity *m_pRootHighestParent;
+	CTraceFilterAgainstEntityList	m_pushersOnly;
+	int m_collisionGroups[8];
+	int m_collisionGroupCount;
+};
+
+int CPushBlockerEnum::s_nEnumCount = 0;
+
+//-----------------------------------------------------------------------------
+// Generates a list of potential blocking entities
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::GenerateBlockingEntityList()
+{
+	VPROF("CPhysicsPushedEntities::GenerateBlockingEntityList");
+
+	m_rgMoved.RemoveAll();
+	CPushBlockerEnum blockerEnum( this );
+
+	for ( int i = m_rgPusher.Count(); --i >= 0;  )
+	{
+		CBaseEntity *pPusher = m_rgPusher[i].m_pEntity;
+
+		// Don't bother if the pusher isn't solid
+		if ( !pPusher->IsSolid() || pPusher->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
+		{
+			continue;
+		}
+
+		Vector vecAbsMins, vecAbsMaxs;
+		pPusher->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
+		partition->EnumerateElementsInBox( PARTITION_ENGINE_NON_STATIC_EDICTS, vecAbsMins, vecAbsMaxs, false, &blockerEnum );
+
+		//Go back throught the generated list.
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Generates a list of potential blocking entities
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::GenerateBlockingEntityListAddBox( const Vector &vecMoved )
+{
+	VPROF("CPhysicsPushedEntities::GenerateBlockingEntityListAddBox");
+
+	m_rgMoved.RemoveAll();
+	CPushBlockerEnum blockerEnum( this );
+
+	for ( int i = m_rgPusher.Count(); --i >= 0;  )
+	{
+		CBaseEntity *pPusher = m_rgPusher[i].m_pEntity;
+
+		// Don't bother if the pusher isn't solid
+		if ( !pPusher->IsSolid() || pPusher->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
+		{
+			continue;
+		}
+
+		Vector vecAbsMins, vecAbsMaxs;
+		pPusher->CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
+		for ( int iAxis = 0; iAxis < 3; ++iAxis )
+		{
+			if ( vecMoved[iAxis] >= 0.0f )
+			{
+				vecAbsMins[iAxis] -= vecMoved[iAxis];
+			}
+			else
+			{
+				vecAbsMaxs[iAxis] -= vecMoved[iAxis];
+			}
+		}
+
+		partition->EnumerateElementsInBox( PARTITION_ENGINE_NON_STATIC_EDICTS, vecAbsMins, vecAbsMaxs, false, &blockerEnum );
+
+		//Go back throught the generated list.
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets a list of all entities hierarchically attached to the root 
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::SetupAllInHierarchy( CBaseEntity *pParent )
+{
+	if (!pParent)
+		return;
+
+	VPROF("CPhysicsPushedEntities::SetupAllInHierarchy");
+
+	// Make sure to snack the position +before+ relink because applying the
+	// rotation (which occurs in relink) will put it at the final location
+	// NOTE: The root object at this point is actually at its final position.
+	// We'll fix that up later
+	int i = m_rgPusher.AddToTail();
+	m_rgPusher[i].m_pEntity = pParent;
+	m_rgPusher[i].m_vecStartAbsOrigin = pParent->GetAbsOrigin();
+
+	CBaseEntity *pChild;
+	for ( pChild = pParent->FirstMoveChild(); pChild != NULL; pChild = pChild->NextMovePeer() )
+	{
+		SetupAllInHierarchy( pChild );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Rotates the root entity, fills in the pushmove structure
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::RotateRootEntity( CBaseEntity *pRoot, float movetime, RotatingPushMove_t &rotation )
+{
+	VPROF("CPhysicsPushedEntities::RotateRootEntity");
+
+	rotation.amove = pRoot->GetLocalAngularVelocity() * movetime;
+	rotation.origin = pRoot->GetAbsOrigin();
+
+	// Knowing the initial + ending basis is needed for determining
+	// which corner we're pushing 
+	MatrixCopy( pRoot->EntityToWorldTransform(), rotation.startLocalToWorld );
+
+	// rotate the pusher to it's final position
+	QAngle angles = pRoot->GetLocalAngles();
+	angles += pRoot->GetLocalAngularVelocity() * movetime;
+
+	pRoot->SetLocalAngles( angles );
+	
+	// Compute the change in absangles
+	MatrixCopy( pRoot->EntityToWorldTransform(), rotation.endLocalToWorld );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tries to rotate an entity hierarchy, returns the blocker if any
+//-----------------------------------------------------------------------------
+CBaseEntity *CPhysicsPushedEntities::PerformRotatePush( CBaseEntity *pRoot, float movetime )
+{
+	VPROF("CPhysicsPushedEntities::PerformRotatePush");
+
+	m_bIsUnblockableByPlayer = (pRoot->GetFlags() & FL_UNBLOCKABLE_BY_PLAYER) ? true : false;
+	// Build a list of this entity + all its children because we're going to try to move them all
+	// This will also make sure each entity is linked in the appropriate place
+	// with correct absboxes
+	m_rgPusher.RemoveAll();
+	SetupAllInHierarchy( pRoot );
+
+	// save where we rotated from, in case we're blocked
+	QAngle angPrevAngles = pRoot->GetLocalAngles();
+
+	// Apply the rotation
+	RotatingPushMove_t	rotPushMove;
+	RotateRootEntity( pRoot, movetime, rotPushMove );
+
+	// Next generate a list of all entities that could potentially be intersecting with
+	// any of the children in their new locations...
+	GenerateBlockingEntityList( );
+
+	// Now we have a unique list of things that could potentially block our push
+	// and need to be pushed out of the way. Lets try to push them all out of the way.
+	// If we fail, undo it all
+	if (!SpeculativelyCheckRotPush( rotPushMove, pRoot ))
+	{
+		CBaseEntity *pBlocker = RegisterBlockage();
+		pRoot->SetLocalAngles( angPrevAngles );
+		RestoreEntities( );
+		return pBlocker;
+	}
+
+	FinishPush( true, &rotPushMove );
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Linearly moves the root entity
+//-----------------------------------------------------------------------------
+void CPhysicsPushedEntities::LinearlyMoveRootEntity( CBaseEntity *pRoot, float movetime, Vector *pAbsPushVector )
+{
+	VPROF("CPhysicsPushedEntities::LinearlyMoveRootEntity");
+
+	// move the pusher to it's final position
+	Vector move = pRoot->GetLocalVelocity() * movetime;
+	Vector origin = pRoot->GetLocalOrigin();
+	origin += move;		
+	pRoot->SetLocalOrigin( origin );
+
+	// Store off the abs push vector
+	*pAbsPushVector = pRoot->GetAbsVelocity() * movetime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tries to linearly push an entity hierarchy, returns the blocker if any
+//-----------------------------------------------------------------------------
+CBaseEntity *CPhysicsPushedEntities::PerformLinearPush( CBaseEntity *pRoot, float movetime )
+{
+	VPROF("CPhysicsPushedEntities::PerformLinearPush");
+
+	m_flMoveTime = movetime;
+
+	m_bIsUnblockableByPlayer = (pRoot->GetFlags() & FL_UNBLOCKABLE_BY_PLAYER) ? true : false;
+	// Build a list of this entity + all its children because we're going to try to move them all
+	// This will also make sure each entity is linked in the appropriate place
+	// with correct absboxes
+	m_rgPusher.RemoveAll();
+	SetupAllInHierarchy( pRoot );
+
+	// save where we started from, in case we're blocked
+	Vector vecPrevOrigin = pRoot->GetLocalOrigin();
+
+	// Move the root (and all children) into its new position
+	Vector vecAbsPush;
+	LinearlyMoveRootEntity( pRoot, movetime, &vecAbsPush );
+
+	// Next generate a list of all entities that could potentially be intersecting with
+	// any of the children in their new locations...
+	GenerateBlockingEntityListAddBox( vecAbsPush );
+
+	// Now we have a unique list of things that could potentially block our push
+	// and need to be pushed out of the way. Lets try to push them all out of the way.
+	// If we fail, undo it all
+	if (!SpeculativelyCheckLinearPush( vecAbsPush ))
+	{
+		CBaseEntity *pBlocker = RegisterBlockage();
+		pRoot->SetLocalOrigin( vecPrevOrigin );
+		RestoreEntities();
+		return pBlocker;
+	}
+
+	FinishPush( );
+	return NULL;
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// CBaseEntity methods
+//
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when it's time for a physically moved objects (plats, doors, etc)
+//			to run it's game code.
+//			All other entity thinking is done during worldspawn's think
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsDispatchThink( BASEPTR thinkFunc )
+{
+	VPROF_ENTER_SCOPE( ( !vprof_scope_entity_thinks.GetBool() ) ? 
+						"CBaseEntity::PhysicsDispatchThink" : 
+						EntityFactoryDictionary()->GetCannonicalName( GetClassname() ) );
+
+	float thinkLimit = think_limit.GetFloat();
+	
+	// The thinkLimit stuff makes a LOT of calls to Sys_FloatTime, which winds up calling into
+	// VCR mode so much that the framerate becomes unusable.
+	if ( VCRGetMode() != VCR_Disabled )
+		thinkLimit = 0;
+
+	float startTime = 0.0;
+
+	if ( IsDormant() )
+	{
+		Warning( "Dormant entity %s (%s) is thinking!!\n", GetClassname(), GetDebugName() );
+		Assert(0);
+	}
+
+	if ( thinkLimit )
+	{
+		startTime = engine->Time();
+	}
+	
+	if ( thinkFunc )
+	{
+		MDLCACHE_CRITICAL_SECTION();
+		(this->*thinkFunc)();
+	}
+
+	if ( thinkLimit )
+	{
+		// calculate running time of the AI in milliseconds
+		float time = ( engine->Time() - startTime ) * 1000.0f;
+		if ( time > thinkLimit )
+		{
+#if defined( _XBOX ) && !defined( _RETAIL )
+			if ( vprof_think_limit.GetBool() )
+			{
+				extern bool g_VProfSignalSpike;
+				g_VProfSignalSpike = true;
+			}
+#endif
+			// If its an NPC print out the shedule/task that took so long
+			CAI_BaseNPC *pNPC = MyNPCPointer();
+			if (pNPC && pNPC->GetCurSchedule())
+			{
+				pNPC->ReportOverThinkLimit( time );
+			}
+			else
+			{
+#ifdef _WIN32
+				Msg( "%s(%s) thinking for %.02f ms!!!\n", GetClassname(), typeid(this).raw_name(), time );
+#elif POSIX
+				Msg( "%s(%s) thinking for %.02f ms!!!\n", GetClassname(), typeid(this).name(), time );
+#else
+#error "typeinfo"
+#endif
+			}
+		}
+	}
+
+	VPROF_EXIT_SCOPE();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Does not change the entities velocity at all
+// Input  : push - 
+// Output : trace_t
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsCheckSweep( const Vector& vecAbsStart, const Vector &vecAbsDelta, trace_t *pTrace )
+{
+	::PhysicsCheckSweep( this, vecAbsStart, vecAbsDelta, pTrace );
+}
+
+
+
+#define	MAX_CLIP_PLANES	5
+//-----------------------------------------------------------------------------
+// Purpose: The basic solid body movement attempt/clip that slides along multiple planes
+// Input  : time - Amount of time to try moving for
+//			*steptrace - if not NULL, the trace results of any vertical wall hit will be stored
+// Output : int - the clipflags if the velocity was modified (hit something solid)
+//   1 = floor
+//   2 = wall / step
+//   4 = dead stop
+//-----------------------------------------------------------------------------
+int CBaseEntity::PhysicsTryMove( float flTime, trace_t *steptrace )
+{
+	VPROF("CBaseEntity::PhysicsTryMove");
+
+	int			bumpcount, numbumps;
+	Vector		dir;
+	float		d;
+	int			numplanes;
+	Vector		planes[MAX_CLIP_PLANES];
+	Vector		primal_velocity, original_velocity, new_velocity;
+	int			i, j;
+	trace_t		trace;
+	Vector		end;
+	float		time_left;
+	int			blocked;
+	
+	unsigned int mask = PhysicsSolidMaskForEntity();
+
+	new_velocity.Init();
+
+	numbumps = 4;
+
+	Vector vecAbsVelocity = GetAbsVelocity();
+
+	blocked = 0;
+	VectorCopy (vecAbsVelocity, original_velocity);
+	VectorCopy (vecAbsVelocity, primal_velocity);
+	numplanes = 0;
+	
+	time_left = flTime;
+
+	for (bumpcount=0 ; bumpcount<numbumps ; bumpcount++)
+	{
+		if (vecAbsVelocity == vec3_origin)
+			break;
+
+		VectorMA( GetAbsOrigin(), time_left, vecAbsVelocity, end );
+
+		Physics_TraceEntity( this, GetAbsOrigin(), end, mask, &trace );
+
+		if (trace.startsolid)
+		{	// entity is trapped in another solid
+			SetAbsVelocity(vec3_origin);
+			return 4;
+		}
+
+		if (trace.fraction > 0)
+		{	// actually covered some distance
+			SetAbsOrigin( trace.endpos );
+			VectorCopy (vecAbsVelocity, original_velocity);
+			numplanes = 0;
+		}
+
+		if (trace.fraction == 1)
+			 break;		// moved the entire distance
+
+		if (!trace.m_pEnt)
+		{
+			SetAbsVelocity( vecAbsVelocity );
+			Warning( "PhysicsTryMove: !trace.u.ent" );
+			Assert(0);
+			return 4;
+		}
+
+		if (trace.plane.normal[2] > 0.7)
+		{
+			blocked |= 1;		// floor
+			if (CanStandOn( trace.m_pEnt ))
+			{
+				// keep track of time when changing ground entity
+				if (GetGroundEntity() != trace.m_pEnt)
+				{
+					SetGroundChangeTime( gpGlobals->curtime + (flTime - (1 - trace.fraction) * time_left) );
+				}
+
+				SetGroundEntity( trace.m_pEnt );
+			}
+		}
+		if (!trace.plane.normal[2])
+		{
+			blocked |= 2;		// step
+			if (steptrace)
+				*steptrace = trace;	// save for player extrafriction
+		}
+
+		// run the impact function
+		PhysicsImpact( trace.m_pEnt, trace );
+		// Removed by the impact function
+		if ( IsMarkedForDeletion() || IsEdictFree() )
+			break;		
+	
+		time_left -= time_left * trace.fraction;
+		
+		// clipped to another plane
+		if (numplanes >= MAX_CLIP_PLANES)
+		{	// this shouldn't really happen
+			SetAbsVelocity(vec3_origin);
+			return blocked;
+		}
+
+		VectorCopy (trace.plane.normal, planes[numplanes]);
+		numplanes++;
+
+		// modify original_velocity so it parallels all of the clip planes
+		if ( GetMoveType() == MOVETYPE_WALK && (!(GetFlags() & FL_ONGROUND) || GetFriction()!=1) )	// relfect player velocity
+		{
+			for ( i = 0; i < numplanes; i++ )
+			{
+				if ( planes[i][2] > 0.7  )
+				{// floor or slope
+					PhysicsClipVelocity( original_velocity, planes[i], new_velocity, 1 );
+					VectorCopy( new_velocity, original_velocity );
+				}
+				else
+				{
+					PhysicsClipVelocity( original_velocity, planes[i], new_velocity, 1.0 + sv_bounce.GetFloat() * (1-GetFriction()) );
+				}
+			}
+
+			VectorCopy( new_velocity, vecAbsVelocity );
+			VectorCopy( new_velocity, original_velocity );
+		}
+		else
+		{
+			for (i=0 ; i<numplanes ; i++)
+			{
+				PhysicsClipVelocity (original_velocity, planes[i], new_velocity, 1);
+				for (j=0 ; j<numplanes ; j++)
+					if (j != i)
+					{
+						if (DotProduct (new_velocity, planes[j]) < 0)
+							break;	// not ok
+					}
+				if (j == numplanes)
+					break;
+			}
+			
+			if (i != numplanes)
+			{	
+				// go along this plane
+				VectorCopy (new_velocity, vecAbsVelocity);
+			}
+			else
+			{	
+				// go along the crease
+				if (numplanes != 2)
+				{
+	//				Msg( "clip velocity, numplanes == %i\n",numplanes);
+					SetAbsVelocity( vecAbsVelocity );
+					return blocked;
+				}
+				CrossProduct (planes[0], planes[1], dir);
+				d = DotProduct (dir, vecAbsVelocity);
+				VectorScale (dir, d, vecAbsVelocity);
+			}
+
+			//
+			// if original velocity is against the original velocity, stop dead
+			// to avoid tiny oscillations in sloping corners
+			//
+			if (DotProduct (vecAbsVelocity, primal_velocity) <= 0)
+			{
+				SetAbsVelocity(vec3_origin);
+				return blocked;
+			}
+		}
+	}
+
+	SetAbsVelocity( vecAbsVelocity );
+	return blocked;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Applies 1/2 gravity to falling movetype step objects
+//			Simulation should be done assuming average velocity over the time 
+//			interval.  Since that would effect a lot of code, and since most of 
+//			that code is going away, it's easier to just add in the average effect 
+//			of gravity on the velocity over the interval at the beginning of similation, 
+//			then add it in again at the end of simulation so that the final velocity is
+//			correct for the entire interval.
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsAddHalfGravity( float timestep )
+{
+	VPROF("CBaseEntity::PhysicsAddHalfGravity");
+	float	ent_gravity;
+
+	if ( GetGravity() )
+	{
+		ent_gravity = GetGravity();
+	}
+	else
+	{
+		ent_gravity = 1.0;
+	}
+
+	// Add 1/2 of the total gravitational effects over this timestep
+	Vector vecAbsVelocity = GetAbsVelocity();
+	vecAbsVelocity[2] -= ( 0.5 * ent_gravity * GetCurrentGravity() * timestep );
+	vecAbsVelocity[2] += GetBaseVelocity()[2] * gpGlobals->frametime;
+	SetAbsVelocity( vecAbsVelocity );
+
+	Vector vecNewBaseVelocity = GetBaseVelocity();
+	vecNewBaseVelocity[2] = 0;
+	SetBaseVelocity( vecNewBaseVelocity );
+	
+	// Bound velocity
+	PhysicsCheckVelocity();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Does not change the entities velocity at all
+// Input  : push - 
+// Output : trace_t
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsPushEntity( const Vector& push, trace_t *pTrace )
+{
+	VPROF("CBaseEntity::PhysicsPushEntity");
+
+	if ( GetMoveParent() )
+	{
+		Warning( "pushing entity (%s) that has parent (%s)!\n", GetDebugName(), GetMoveParent()->GetDebugName() );
+		Assert(0);
+	}
+
+	// NOTE: absorigin and origin must be equal because there is no moveparent
+	Vector prevOrigin;
+	VectorCopy( GetAbsOrigin(), prevOrigin );
+
+	::PhysicsCheckSweep( this, prevOrigin, push, pTrace );
+
+	if ( pTrace->fraction )
+	{
+		SetAbsOrigin( pTrace->endpos );
+
+		// FIXME(ywb):  Should we try to enable this here
+		// WakeRestingObjects();
+	}
+
+	// Passing in the previous abs origin here will cause the relinker
+	// to test the swept ray from previous to current location for trigger intersections
+	PhysicsTouchTriggers( &prevOrigin );
+
+	if ( pTrace->m_pEnt )
+	{
+		PhysicsImpact( pTrace->m_pEnt, *pTrace );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:  See if entity is inside another entity, if so, returns true if so, fills in *ppEntity if ppEntity is not NULL
+// Input  : **ppEntity - optional return pointer to entity we are inside of
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseEntity::PhysicsTestEntityPosition( CBaseEntity **ppEntity /*=NULL*/ )
+{
+	VPROF("CBaseEntity::PhysicsTestEntityPosition");
+
+	trace_t	trace;
+	
+	unsigned int mask = PhysicsSolidMaskForEntity();
+
+	Physics_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), mask, &trace );
+	
+	if ( trace.startsolid )
+	{
+		if ( ppEntity )
+		{
+			*ppEntity = trace.m_pEnt;
+		}
+		return true;
+	}
+		
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseEntity *CBaseEntity::PhysicsPushMove( float movetime )
+{
+	VPROF("CBaseEntity::PhysicsPushMove");
+
+	// If this entity isn't moving, just update the time.
+	IncrementLocalTime( movetime );
+
+	if ( GetLocalVelocity() == vec3_origin )
+	{
+		return NULL;
+	}
+
+	// Now check that the entire hierarchy can rotate into the new location
+	CBaseEntity *pBlocker = g_pPushedEntities->PerformLinearPush( this, movetime );
+	if ( pBlocker )
+	{
+		IncrementLocalTime( -movetime );
+	}
+	return pBlocker;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tries to rotate, returns success or failure
+// Input  : movetime - 
+// Output : bool
+//-----------------------------------------------------------------------------
+CBaseEntity *CBaseEntity::PhysicsPushRotate( float movetime )
+{
+	VPROF("CBaseEntity::PhysicsPushRotate");
+
+	IncrementLocalTime( movetime );
+
+	// Not rotating
+	if ( GetLocalAngularVelocity() == vec3_angle )
+	{
+		return NULL;
+	}
+
+	// Now check that the entire hierarchy can rotate into the new location
+	CBaseEntity *pBlocker = g_pPushedEntities->PerformRotatePush( this, movetime );
+	if ( pBlocker )
+	{
+		IncrementLocalTime( -movetime );
+	}
+
+	return pBlocker;
+}
+
+
+//-----------------------------------------------------------------------------
+// Block of icky shared code from PhysicsParent + PhysicsPusher
+//-----------------------------------------------------------------------------
+void CBaseEntity::PerformPush( float movetime )
+{
+	VPROF("CBaseEntity::PerformPush");
+	// NOTE: Use handle index because the previous blocker could have been deleted
+	int hPrevBlocker = m_pBlocker.ToInt();
+	CBaseEntity *pBlocker;
+	g_pPushedEntities->BeginPush( this );
+	if (movetime > 0)
+	{
+		if ( GetLocalAngularVelocity() != vec3_angle )
+		{
+			if ( GetLocalVelocity() != vec3_origin )
+			{
+				// NOTE: Both PhysicsPushRotate + PhysicsPushMove
+				// will attempt to advance local time. Choose the one that's
+				// the greater of the two from push + move
+
+				// FIXME: Should we really be doing them both simultaneously??
+				// FIXME: Choose the *greater* of the two?!? That's strange...
+				float flInitialLocalTime = m_flLocalTime;
+
+				// moving and rotating, so rotate first, then move
+				pBlocker = PhysicsPushRotate( movetime );
+				if ( !pBlocker )
+				{
+					float flRotateLocalTime = m_flLocalTime;
+
+					// Reset the local time to what it was before we rotated
+					m_flLocalTime = flInitialLocalTime;
+					pBlocker = PhysicsPushMove( movetime );
+					if ( m_flLocalTime < flRotateLocalTime )
+					{
+						m_flLocalTime = flRotateLocalTime;
+					}
+				}
+			}
+			else
+			{
+				// only rotating
+				pBlocker = PhysicsPushRotate( movetime );
+			}
+		}
+		else
+		{
+			// only moving
+			pBlocker = PhysicsPushMove( movetime );
+		}
+
+		m_pBlocker = pBlocker;
+		if (m_pBlocker.ToInt() != hPrevBlocker)
+		{
+			if (hPrevBlocker != INVALID_EHANDLE_INDEX)
+			{
+				EndBlocked();
+			}
+			if (m_pBlocker)
+			{
+				StartBlocked( pBlocker );
+			}
+		}
+		if (m_pBlocker)
+		{
+			Blocked( m_pBlocker );
+		}
+
+		// NOTE NOTE: This is here for brutal reasons.
+		// For MOVETYPE_PUSH objects with VPhysics shadow objects, the move done time
+		// is handled by CBaseEntity::VPhyicsUpdatePusher, which only gets called if
+		// the physics system thinks the entity is awake. That will happen if the
+		// shadow gets updated, but the push code above doesn't update unless the
+		// move is successful or non-zero. So we must make sure it's awake
+		if ( VPhysicsGetObject() )
+		{
+			VPhysicsGetObject()->Wake();
+		}
+	}
+
+	// move done is handled by physics if it has any
+	if ( VPhysicsGetObject() )
+	{
+		// store the list of moved entities for later
+		// if you actually did an unblocked push that moved entities, and you're using physics (which may block later)
+		if ( movetime > 0 && !m_pBlocker && GetSolid() == SOLID_VPHYSICS && g_pPushedEntities->CountMovedEntities() > 0 )
+		{
+			// UNDONE: Any reason to want to call this twice before physics runs?
+			// If so, maybe just append to the list?
+			Assert( !GetDataObject( PHYSICSPUSHLIST ) );
+			physicspushlist_t *pList = (physicspushlist_t *)CreateDataObject( PHYSICSPUSHLIST );
+			if ( pList )
+			{
+				g_pPushedEntities->StoreMovedEntities( *pList );
+			}
+		}
+	}
+	else
+	{
+		if ( m_flMoveDoneTime <= m_flLocalTime && m_flMoveDoneTime > 0 )
+		{
+			SetMoveDoneTime( -1 );
+			MoveDone();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: UNDONE: This is only different from PhysicsParent because of the callback to PhysicsVelocity()
+// Can we support that callback in push objects as well?
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsPusher( void )
+{
+	VPROF("CBaseEntity::PhysicsPusher");
+
+	// regular thinking
+	if ( !PhysicsRunThink() )
+		return;
+
+	m_flVPhysicsUpdateLocalTime = m_flLocalTime;
+
+	float movetime = GetMoveDoneTime();
+	if (movetime > gpGlobals->frametime)
+	{
+		movetime = gpGlobals->frametime;
+	}
+
+	PerformPush( movetime );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Non moving objects can only think
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsNone( void )
+{
+	VPROF("CBaseEntity::PhysicsNone");
+
+	// regular thinking
+	PhysicsRunThink();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A moving object that doesn't obey physics
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsNoclip( void )
+{
+	VPROF("CBaseEntity::PhysicsNoclip");
+
+	// regular thinking
+	if ( !PhysicsRunThink() )
+	{
+		return;
+	}
+	
+	// Apply angular velocity
+	SimulateAngles( gpGlobals->frametime );
+
+	Vector origin;
+	VectorMA( GetLocalOrigin(), gpGlobals->frametime, GetLocalVelocity(), origin );
+	SetLocalOrigin( origin );
+}
+
+
+void CBaseEntity::PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
+{
+	// If you're going to use custom physics, you need to implement this!
+	Assert(0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Allows entities to describe their own physics
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsCustom()
+{
+	VPROF("CBaseEntity::PhysicsCustom");
+	PhysicsCheckWater();
+
+	// regular thinking
+	if ( !PhysicsRunThink() )
+		return;
+
+	// Moving upward, off the ground, or  resting on a client/monster, remove FL_ONGROUND
+	if ( m_vecVelocity[2] > 0 || !GetGroundEntity() || !GetGroundEntity()->IsStandable() )
+	{
+		SetGroundEntity( NULL );
+	}
+
+	// NOTE: The entity must set the position, angles, velocity in its custom movement
+	Vector vecNewPosition = GetAbsOrigin();
+	Vector vecNewVelocity = GetAbsVelocity();
+	QAngle angNewAngles = GetAbsAngles();
+	QAngle angNewAngVelocity = GetLocalAngularVelocity();
+
+	PerformCustomPhysics( &vecNewPosition, &vecNewVelocity, &angNewAngles, &angNewAngVelocity );
+
+	// Store off all of the new state information...
+	SetAbsVelocity( vecNewVelocity );
+	SetAbsAngles( angNewAngles );
+	SetLocalAngularVelocity( angNewAngVelocity );
+
+	Vector move;
+	VectorSubtract( vecNewPosition, GetAbsOrigin(), move );
+
+	// move origin
+	trace_t trace;
+	PhysicsPushEntity( move, &trace );
+
+	PhysicsCheckVelocity();
+
+	if (trace.allsolid)
+	{	
+		// entity is trapped in another solid
+		// UNDONE: does this entity needs to be removed?
+		SetAbsVelocity(vec3_origin);
+		SetLocalAngularVelocity(vec3_angle);
+		return;
+	}
+	
+	if (IsEdictFree())
+		return;
+
+	// check for in water
+	PhysicsCheckWaterTransition();
+}
+
+bool g_bTestMoveTypeStepSimulation = true;
+ConVar sv_teststepsimulation( "sv_teststepsimulation", "1", 0 );
+
+//-----------------------------------------------------------------------------
+// Purpose: Until we remove the above cvar, we need to have the entities able
+//  to dynamically deal with changing their simulation stuff here.
+//-----------------------------------------------------------------------------
+void CBaseEntity::CheckStepSimulationChanged()
+{
+	if ( g_bTestMoveTypeStepSimulation != IsSimulatedEveryTick() )
+	{
+		SetSimulatedEveryTick( g_bTestMoveTypeStepSimulation );
+	}
+
+	bool hadobject = HasDataObjectType( STEPSIMULATION );
+
+	if ( g_bTestMoveTypeStepSimulation )
+	{
+		if ( !hadobject )
+		{
+			CreateDataObject( STEPSIMULATION );
+		}
+	}
+	else
+	{
+		if ( hadobject )
+		{
+			DestroyDataObject( STEPSIMULATION );
+		}
+	}
+}
+
+
+#define STEP_TELPORTATION_VEL_SQ	( 4096.0f * 4096.0f )
+//-----------------------------------------------------------------------------
+// Purpose: Run regular think and latch off angle/origin changes so we can interpolate them on the server to fake simulation
+// Input  : *step - 
+//-----------------------------------------------------------------------------
+void CBaseEntity::StepSimulationThink( float dt )
+{
+	// See if we need to allocate, deallocate step simulation object
+	CheckStepSimulationChanged();
+
+	StepSimulationData *step = ( StepSimulationData * )GetDataObject( STEPSIMULATION );
+	if ( !step )
+	{
+		PhysicsStepRunTimestep( dt );
+
+		// Just call the think function directly
+		PhysicsRunThink( THINK_FIRE_BASE_ONLY );
+	}
+	else
+	{
+		// Assume that it's in use
+		step->m_bOriginActive = true;
+		step->m_bAnglesActive = true;
+
+		// Reset networked versions of origin and angles
+		step->m_nLastProcessTickCount = -1;
+		step->m_vecNetworkOrigin.Init();
+		step->m_angNetworkAngles.Init();
+
+		// Remember old old values
+		step->m_Previous2 = step->m_Previous;
+
+		// Remember old values
+		step->m_Previous.nTickCount = gpGlobals->tickcount;
+		step->m_Previous.vecOrigin = GetStepOrigin();
+		QAngle stepAngles = GetStepAngles();
+		AngleQuaternion( stepAngles, step->m_Previous.qRotation );
+
+		// Run simulation
+		PhysicsStepRunTimestep( dt );
+
+		// Call the actual think function...
+		PhysicsRunThink( THINK_FIRE_BASE_ONLY );
+
+		// do any local processing that's needed
+		if (GetBaseAnimating() != NULL)
+		{
+			GetBaseAnimating()->UpdateStepOrigin();
+		}
+
+		// Latch new values to see if external code modifies our position/orientation
+		step->m_Next.vecOrigin = GetStepOrigin();
+		stepAngles = GetStepAngles();
+		AngleQuaternion( stepAngles, step->m_Next.qRotation );
+		// Also store of non-Quaternion version for simple comparisons
+		step->m_angNextRotation = GetStepAngles();
+		step->m_Next.nTickCount = GetNextThinkTick();
+
+		// Hack:  Add a tick if we are simulating every other tick
+		if ( CBaseEntity::IsSimulatingOnAlternateTicks() )
+		{
+			++step->m_Next.nTickCount;
+		}
+
+		// Check for teleportation/snapping of the origin
+		if ( dt > 0.0f )
+		{
+			Vector deltaorigin = step->m_Next.vecOrigin - step->m_Previous.vecOrigin;
+			float velSq = deltaorigin.LengthSqr() / ( dt * dt );
+			if ( velSq >= STEP_TELPORTATION_VEL_SQ )
+			{
+				// Deactivate it due to large origin change
+				step->m_bOriginActive = false;
+				step->m_bAnglesActive = false;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Monsters freefall when they don't have a ground entity, otherwise
+//   all movement is done with discrete steps.
+// This is also used for objects that have become still on the ground, but
+//  will fall if the floor is pulled out from under them.
+// JAY: Extended this to synchronize movement and thinking wherever possible.
+// This allows the client-side interpolation to interpolate animation and simulation
+// data at the same time.
+// UNDONE:	Remove all other cases from this loop - only use MOVETYPE_STEP to simulate
+//			entities that are currently animating/thinking.
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsStep()
+{
+	// EVIL HACK: Force these to appear as if they've changed!!!
+	// The underlying values don't actually change, but we need the network sendproxy on origin/angles
+	//  to get triggered, and that only happens if NetworkStateChanged() appears to have occured.
+	// Getting them for modify marks them as changed automagically.
+	m_vecOrigin.GetForModify();
+	m_angRotation.GetForModify();
+	
+	// HACK:  Make sure that the client latches the networked origin/orientation changes with the current server tick count
+	//  so that we don't get jittery interpolation.  All of this is necessary to mimic actual continuous simulation of the underlying
+	//  variables.
+	SetSimulationTime( gpGlobals->curtime );
+	
+	// Run all but the base think function
+	PhysicsRunThink( THINK_FIRE_ALL_BUT_BASE );
+
+	int thinktick = GetNextThinkTick();
+	float thinktime = thinktick * TICK_INTERVAL;
+
+	// Is the next think too far out, or non-existent?
+	// BUGBUG: Interpolation is going to look bad in here.  But it should only
+	// be for dead things - and those should be ragdolls (client-side sim) anyway.
+	// UNDONE: Remove this and assert?  Force MOVETYPE_STEP objs to become MOVETYPE_TOSS when
+	// they aren't thinking?
+	// UNDONE: this happens as the first frame for a bunch of things like dynamically created ents.
+	// can't remove until initial conditions are resolved
+	float deltaThink = thinktime - gpGlobals->curtime;
+	if ( thinktime <= 0 || deltaThink > 0.5 )
+	{
+		PhysicsStepRunTimestep( gpGlobals->frametime );
+		PhysicsCheckWaterTransition();
+		SetLastThink( -1, gpGlobals->curtime );
+		UpdatePhysicsShadowToCurrentPosition(gpGlobals->frametime);
+		PhysicsRelinkChildren(gpGlobals->frametime);
+		return;
+	}
+
+	Vector oldOrigin = GetAbsOrigin();
+
+	// Feed the position delta back from vphysics if enabled
+	bool updateFromVPhysics = npc_vphysics.GetBool();
+	if ( HasDataObjectType(VPHYSICSUPDATEAI) )
+	{
+		vphysicsupdateai_t *pUpdate = static_cast<vphysicsupdateai_t *>(GetDataObject( VPHYSICSUPDATEAI ));
+		if ( pUpdate->stopUpdateTime > gpGlobals->curtime )
+		{
+			updateFromVPhysics = true;
+		}
+		else
+		{
+			float maxAngular;
+			VPhysicsGetObject()->GetShadowController()->GetMaxSpeed( NULL, &maxAngular );
+			VPhysicsGetObject()->GetShadowController()->MaxSpeed( pUpdate->savedShadowControllerMaxSpeed, maxAngular );
+			DestroyDataObject(VPHYSICSUPDATEAI);
+		}
+	}
+
+	if ( updateFromVPhysics && VPhysicsGetObject() && !GetParent() )
+	{
+		Vector position;
+		VPhysicsGetObject()->GetShadowPosition( &position, NULL );
+		float delta = (GetAbsOrigin() - position).LengthSqr();
+		// for now, use a tolerance of 1 inch for these tests
+		if ( delta < 1 )
+		{
+			// physics is really close, check to see if my current position is valid.
+			// If so, ignore the physics result.
+			trace_t tr;
+			Physics_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), PhysicsSolidMaskForEntity(), &tr );
+			updateFromVPhysics = tr.startsolid;
+		}
+		if ( updateFromVPhysics )
+		{
+			SetAbsOrigin( position );
+			PhysicsTouchTriggers();
+		}
+		//NDebugOverlay::Box( position, WorldAlignMins(), WorldAlignMaxs(), 255, 255, 0, 0, 0.0 );
+	}
+
+	// not going to think, don't run game physics either
+	if ( thinktick > gpGlobals->tickcount )
+		return;
+	
+	// Don't let things stay in the past.
+	//  it is possible to start that way
+	//  by a trigger with a local time.
+	if ( thinktime < gpGlobals->curtime )
+	{
+		thinktime = gpGlobals->curtime;	
+	}
+
+	// simulate over the timestep
+	float dt = thinktime - GetLastThink();
+
+	// Now run step simulator
+	StepSimulationThink( dt );
+
+	PhysicsCheckWaterTransition();
+
+	if ( VPhysicsGetObject() )
+	{
+		if ( !VectorCompare( oldOrigin, GetAbsOrigin() ) )
+		{
+			VPhysicsGetObject()->UpdateShadow( GetAbsOrigin(), vec3_angle, (GetFlags() & FL_FLY) ? true : false, dt );
+		}
+	}
+	PhysicsRelinkChildren(dt);
+}
+
+
+void UTIL_TraceLineFilterEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd, 
+					   unsigned int mask, const int nCollisionGroup, trace_t *ptr );
+
+// Check to see what (if anything) this MOVETYPE_STEP entity is standing on
+void CBaseEntity::PhysicsStepRecheckGround()
+{
+	unsigned int mask = PhysicsSolidMaskForEntity();
+	// determine if it's on solid ground at all
+	Vector	mins, maxs, point;
+	int		x, y;
+	trace_t trace;
+	
+	VectorAdd (GetAbsOrigin(), WorldAlignMins(), mins);
+	VectorAdd (GetAbsOrigin(), WorldAlignMaxs(), maxs);
+	point[2] = mins[2] - 1;
+	for	(x=0 ; x<=1 ; x++)
+	{
+		for	(y=0 ; y<=1 ; y++)
+		{
+			point[0] = x ? maxs[0] : mins[0];
+			point[1] = y ? maxs[1] : mins[1];
+
+			ICollideable *pCollision = GetCollideable();
+
+			if ( pCollision && IsNPC() )
+			{
+				UTIL_TraceLineFilterEntity( this, point, point, mask, COLLISION_GROUP_NONE, &trace );
+			}
+			else
+			{
+				UTIL_TraceLine( point, point, mask, this, COLLISION_GROUP_NONE, &trace );
+			}
+
+			if ( trace.startsolid )
+			{
+				SetGroundEntity( trace.m_pEnt );
+				return;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : timestep - 
+//-----------------------------------------------------------------------------
+void CBaseEntity::PhysicsStepRunTimestep( float timestep )
+{
+	bool	wasonground;
+	bool	inwater;
+	bool	hitsound = false;
+	float	speed, newspeed, control;
+	float	friction;
+
+	PhysicsCheckVelocity();
+
+	wasonground = ( GetFlags() & FL_ONGROUND ) ? true : false;
+
+	// add gravity except:
+	//   flying monsters
+	//   swimming monsters who are in the water
+	inwater = PhysicsCheckWater();
+
+	bool isfalling = false;
+
+	if ( !wasonground )
+	{
+		if ( !( GetFlags() & FL_FLY ) )
+		{
+			if ( !( ( GetFlags() & FL_SWIM ) && ( GetWaterLevel() > 0 ) ) )
+			{
+				if ( GetAbsVelocity()[2] < ( GetCurrentGravity() * -0.1 ) )
+				{
+					hitsound = true;
+				}
+
+				if ( !inwater )
+				{
+					PhysicsAddHalfGravity( timestep );
+					isfalling = true;
+				}
+			}
+		}
+	}
+
+	if ( !(GetFlags() & FL_STEPMOVEMENT) &&
+		(!VectorCompare(GetAbsVelocity(), vec3_origin) || 
+		 !VectorCompare(GetBaseVelocity(), vec3_origin)))
+	{
+		Vector vecAbsVelocity = GetAbsVelocity();
+
+		SetGroundEntity( NULL );
+		// apply friction
+		// let dead monsters who aren't completely onground slide
+		if ( wasonground )
+		{
+			speed = VectorLength( vecAbsVelocity );
+			if (speed)
+			{
+				friction = sv_friction.GetFloat() * GetFriction();
+
+				control = speed < sv_stopspeed.GetFloat() ? sv_stopspeed.GetFloat() : speed;
+				newspeed = speed - timestep*control*friction;
+
+				if (newspeed < 0)
+					newspeed = 0;
+				newspeed /= speed;
+
+				vecAbsVelocity[0] *= newspeed;
+				vecAbsVelocity[1] *= newspeed;
+			}
+		}
+
+		vecAbsVelocity += GetBaseVelocity();
+		SetAbsVelocity( vecAbsVelocity );
+
+		// Apply angular velocity
+		SimulateAngles( timestep );
+
+		PhysicsCheckVelocity();
+
+		PhysicsTryMove( timestep, NULL );
+
+		PhysicsCheckVelocity();
+
+		vecAbsVelocity = GetAbsVelocity();
+		vecAbsVelocity -= GetBaseVelocity();
+		SetAbsVelocity( vecAbsVelocity );
+
+		PhysicsCheckVelocity();
+
+		if ( !(GetFlags() & FL_ONGROUND) )
+		{
+			PhysicsStepRecheckGround();
+		}
+
+		PhysicsTouchTriggers();
+	}
+
+	if (!( GetFlags() & FL_ONGROUND ) && isfalling)
+	{
+		PhysicsAddHalfGravity( timestep );
+	}
+}
+
+// After this long, if a player isn't updating, then return it's projectiles to server control
+#define PLAYER_PACKETS_STOPPED_SO_RETURN_TO_PHYSICS_TIME 1.0f
+
+void Physics_SimulateEntity( CBaseEntity *pEntity )
+{
+	VPROF( ( !vprof_scope_entity_gamephys.GetBool() ) ? 
+			"Physics_SimulateEntity" : 
+			EntityFactoryDictionary()->GetCannonicalName( pEntity->GetClassname() ) );
+
+	if ( pEntity->edict() )
+	{
+#if !defined( NO_ENTITY_PREDICTION )
+		// Player drives simulation of this entity
+		if ( pEntity->IsPlayerSimulated() )
+		{
+			// If the player is gone, dropped, crashed, then return
+			//  control to the game code.
+			CBasePlayer *simulatingPlayer = pEntity->GetSimulatingPlayer();
+			if ( simulatingPlayer &&
+				( simulatingPlayer->GetTimeBase() > gpGlobals->curtime - PLAYER_PACKETS_STOPPED_SO_RETURN_TO_PHYSICS_TIME ) )
+			{
+				// Okay, the guy is still around
+				return;
+			}
+
+			pEntity->UnsetPlayerSimulated();
+		}
+#endif
+
+		MDLCACHE_CRITICAL_SECTION();
+
+#if !defined( NO_ENTITY_PREDICTION )
+		// If an object was at one point player simulated, but had that status revoked (as just
+		//  above when no packets have arrived in a while ), then we still will assume that the
+		//  owner/player will be predicting the entity locally (even if the game is playing like butt)
+		//  and so we won't spam that player with additional network data such as effects/sounds 
+		//  that are theoretically being predicted by the player anyway.
+		if ( pEntity->m_PredictableID->IsActive() )
+		{
+			CBasePlayer *playerowner = ToBasePlayer( pEntity->GetOwnerEntity() );
+			if ( playerowner )
+			{
+				CBasePlayer *pl = ToBasePlayer( UTIL_PlayerByIndex( pEntity->m_PredictableID->GetPlayer() + 1 ) );
+				// Is the player who created it still the owner?
+				if ( pl == playerowner )
+				{
+					// Set up to suppress sending events to owner player
+					if ( pl->IsPredictingWeapons() )
+					{
+						IPredictionSystem::SuppressHostEvents( playerowner );
+					}
+				}
+			}	
+			{
+				VPROF( ( !vprof_scope_entity_gamephys.GetBool() ) ? 
+						"pEntity->PhysicsSimulate" : 
+						EntityFactoryDictionary()->GetCannonicalName( pEntity->GetClassname() ) );
+
+				// Run entity physics
+				pEntity->PhysicsSimulate();
+			}
+
+			// Restore suppression filter
+			IPredictionSystem::SuppressHostEvents( NULL );
+		}
+		else
+#endif
+		{
+			// Run entity physics
+			pEntity->PhysicsSimulate();
+		}
+	}
+	else
+	{
+		pEntity->PhysicsRunThink();
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: Runs the main physics simulation loop against all entities ( except players )
+//-----------------------------------------------------------------------------
+void Physics_RunThinkFunctions( bool simulating )
+{
+	VPROF( "Physics_RunThinkFunctions");
+
+	g_bTestMoveTypeStepSimulation = sv_teststepsimulation.GetBool();
+
+	float starttime = gpGlobals->curtime;
+	// clear all entites freed outside of this loop
+	gEntList.CleanupDeleteList();
+
+	if ( !simulating )
+	{
+		// only simulate players
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+			if ( pPlayer )
+			{
+				// Always reset clock to real sv.time
+				gpGlobals->curtime = starttime;
+				// Force usercmd processing even though gpGlobals->tickcount isn't incrementing
+				pPlayer->ForceSimulation();
+				Physics_SimulateEntity( pPlayer );
+			}
+		}
+	}
+	else
+	{
+		UTIL_DisableRemoveImmediate();
+		int listMax = SimThink_ListCount();
+		listMax = MAX(listMax,1);
+		CBaseEntity **list = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * listMax );
+		// iterate through all entities and have them think or simulate
+		
+		// UNDONE: This has problems with UTIL_RemoveImmediate() (now disabled during this loop).  
+		// Do we really need UTIL_RemoveImmediate()?
+		int count = SimThink_ListCopy( list, listMax );
+
+		//DevMsg(1, "Count: %d\n", count );
+		for ( int i = 0; i < count; i++ )
+		{
+			if ( !list[i] )
+				continue;
+			// Always reset clock to real sv.time
+			gpGlobals->curtime = starttime;
+			Physics_SimulateEntity( list[i] );
+		}
+
+		stackfree( list );
+		UTIL_EnableRemoveImmediate();
+	}
+
+	gpGlobals->curtime = starttime;
+}
+