1HEADmaster

1 files changed, 3243 insertions, 0 deletions

diff --git a/game/server/tf2/tf_obj.cpp b/game/server/tf2/tf_obj.cpp
new file mode 100644
index 0000000..cd07213
--- /dev/null
+++ b/game/server/tf2/tf_obj.cpp
@@ -0,0 +1,3243 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Base Object built by players
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_team.h"
+#include "tf_obj.h"
+#include "tf_basecombatweapon.h"
+#include "rope.h"
+#include "rope_shared.h"
+#include "bone_setup.h"
+#include "tf_func_resource.h"
+#include "ndebugoverlay.h"
+#include "rope_helpers.h"
+#include "IEffects.h"
+#include "vstdlib/random.h"
+#include "tier1/strtools.h"
+#include "basegrenade_shared.h"
+#include "grenade_objectsapper.h"
+#include "tf_stats.h"
+#include "tf_gamerules.h"
+#include "engine/IEngineSound.h"
+#include "tf_obj_sentrygun.h"
+#include "tf_obj_powerpack.h"
+#include "tf_shareddefs.h"
+#include "VGuiScreen.h"
+#include "resource_chunk.h"
+#include "hierarchy.h"
+#include "tf_func_construction_yard.h"
+#include "tf_func_no_build.h"
+#include <KeyValues.h>
+#include "team_messages.h"
+#include "info_act.h"
+#include "info_vehicle_bay.h"
+#include "ihasbuildpoints.h"
+#include "tf_obj_buff_station.h"
+#include "info_buildpoint.h"
+#include "utldict.h"
+#include "filesystem.h"
+#include "npcevent.h"
+#include "tf_shareddefs.h"
+#include "animation.h"
+
+// Control panels
+#define SCREEN_OVERLAY_MATERIAL "vgui/screens/vgui_overlay"
+
+#define ROPE_HANG_DIST	150
+
+
+ConVar object_verbose( "object_verbose", "0", 0, "Debug object system." );
+ConVar obj_damage_factor( "obj_damage_factor","0", FCVAR_NONE, "Factor applied to all damage done to objects" );
+ConVar obj_child_damage_factor( "obj_child_damage_factor","0.25", FCVAR_NONE, "Factor applied to damage done to objects that are built on a buildpoint" );
+ConVar tf_fastbuild("tf_fastbuild", "0", FCVAR_CHEAT);
+ConVar tf_obj_ground_clearance( "tf_obj_ground_clearance", "60", 0, "Object corners can be this high above the ground" );
+
+extern short g_sModelIndexFireball;
+
+// Minimum distance between 2 objects to ensure player movement between them
+#define MINIMUM_OBJECT_SAFE_DISTANCE		100
+
+// Maximum number of a type of objects on a single resource zone
+#define MAX_OBJECTS_PER_ZONE			1
+
+// Time it takes a fully healed object to deteriorate
+ConVar  object_deterioration_time( "object_deterioration_time", "30", 0, "Time it takes for a fully-healed object to deteriorate." );
+
+// Time after taking damage that an object will still drop resources on death
+#define MAX_DROP_TIME_AFTER_DAMAGE			5
+
+#define OBJ_BASE_THINK_CONTEXT				"BaseObjectThink"
+#define OBJ_LOSTPOWER_THINK_CONTEXT			"LostPowerThink"
+
+BEGIN_DATADESC( CBaseObject )
+	// keys 
+	DEFINE_KEYFIELD_NOT_SAVED( m_bInvulnerable,		FIELD_BOOLEAN, "Invulnerable" ),
+	DEFINE_KEYFIELD_NOT_SAVED( m_flRepairMultiplier,	FIELD_FLOAT, "RepairMult" ),
+	DEFINE_KEYFIELD_NOT_SAVED( m_iszUnderAttackSound,	FIELD_STRING, "AttackNotify" ), 
+	DEFINE_KEYFIELD_NOT_SAVED( m_flMinDisableHealth,	FIELD_FLOAT, "MinDisabledHealth" ),
+	DEFINE_KEYFIELD_NOT_SAVED( m_SolidToPlayers,		FIELD_INTEGER, "SolidToPlayer" ),
+	DEFINE_KEYFIELD_NOT_SAVED( m_iszDisabledModel,		FIELD_STRING, "DisabledModel" ),
+	DEFINE_KEYFIELD_NOT_SAVED( m_bCantDie,				FIELD_BOOLEAN, "CantDie" ),
+
+	// Inputs
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetHealth", InputSetHealth ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "AddHealth", InputAddHealth ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "RemoveHealth", InputRemoveHealth ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetMinDisabledHealth", InputSetMinDisabledHealth ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetSolidToPlayer", InputSetSolidToPlayer ),
+
+	// Outputs
+	DEFINE_OUTPUT( m_OnDestroyed, "OnDestroyed" ),
+	DEFINE_OUTPUT( m_OnDamaged, "OnDamaged" ),
+	DEFINE_OUTPUT( m_OnRepaired, "OnRepaired" ),
+	DEFINE_OUTPUT( m_OnBecomingDisabled, "OnDisabled" ),
+	DEFINE_OUTPUT( m_OnBecomingReenabled, "OnReenabled" ),
+	DEFINE_OUTPUT( m_OnObjectHealthChanged, "OnObjectHealthChanged" )
+END_DATADESC()
+
+
+IMPLEMENT_SERVERCLASS_ST(CBaseObject, DT_BaseObject)
+	SendPropInt(SENDINFO(m_iHealth), 13 ),
+	SendPropInt(SENDINFO(m_iMaxHealth), 13 ),
+	SendPropInt(SENDINFO(m_bHasSapper), 1, SPROP_UNSIGNED ),
+	SendPropInt(SENDINFO(m_iObjectType),  6, SPROP_UNSIGNED ),
+	SendPropInt(SENDINFO(m_bBuilding), 1, SPROP_UNSIGNED ),
+	SendPropInt(SENDINFO(m_bPlacing), 1, SPROP_UNSIGNED ),
+	SendPropFloat(SENDINFO(m_flPercentageConstructed), 8, 0, 0.0, 1.0f ),
+	SendPropInt(SENDINFO(m_fObjectFlags), OF_BIT_COUNT, SPROP_UNSIGNED ),
+	SendPropInt(SENDINFO(m_bDeteriorating), 1, SPROP_UNSIGNED ),
+	SendPropEHandle(SENDINFO(m_hBuiltOnEntity)),
+	SendPropInt( SENDINFO( m_takedamage ), 2, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bDisabled ), 1, SPROP_UNSIGNED ),
+	SendPropEHandle( SENDINFO( m_hBuilder ) ),
+END_SEND_TABLE();
+
+
+// This controls whether ropes attached to objects are transmitted or not. It's important that
+// ropes aren't transmitted to guys who don't own them.
+class CObjectRopeTransmitProxy : public CBaseTransmitProxy
+{
+public:
+	CObjectRopeTransmitProxy( CBaseEntity *pRope ) : CBaseTransmitProxy( pRope )
+	{
+	}
+	
+	virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo, int nPrevShouldTransmitResult )
+	{
+		// Don't transmit the rope if it's not even visible.
+		if ( !nPrevShouldTransmitResult )
+			return FL_EDICT_DONTSEND;
+
+		// This proxy only wants to be active while one of the two objects is being placed.
+		// When they're done being placed, the proxy goes away and the rope draws like normal.
+		bool bAnyObjectPlacing = (m_hObj1 && m_hObj1->IsPlacing()) || (m_hObj2 && m_hObj2->IsPlacing());
+		if ( !bAnyObjectPlacing )
+		{
+			Release();
+			return nPrevShouldTransmitResult;
+		}
+
+		// Give control to whichever object is being placed.
+		if ( m_hObj1 && m_hObj1->IsPlacing() )
+			return m_hObj1->ShouldTransmit( pInfo );
+		
+		else if ( m_hObj2 && m_hObj2->IsPlacing() )
+			return m_hObj2->ShouldTransmit( pInfo );
+		
+		else
+			return FL_EDICT_ALWAYS;
+	}
+
+
+	CHandle<CBaseObject> m_hObj1;
+	CHandle<CBaseObject> m_hObj2;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObject::CBaseObject()
+{
+	m_hPowerPack = NULL;
+	m_iHealth = m_iMaxHealth = m_flHealth = 0;
+	m_aRopes.Purge();
+	m_flPercentageConstructed = 0;
+	m_bPlacing = false;
+	m_bBuilding = false;
+	m_bInvulnerable = false;
+	m_bCantDie = false;
+	m_bDeteriorating = false;
+	m_flRepairMultiplier = 1;
+	m_hBuffStation = NULL;
+	m_bBuffActivated = false;
+	m_Activity = ACT_OBJ_IDLE;
+	m_bDisabled = false;
+	m_hVehicleBay = NULL;
+	m_flLastRepairTime = 0;
+	m_flNextRepairMultiplier = 0;
+	m_flRepairedSinceLastTime = 0;
+	m_iszUnderAttackSound = NULL_STRING;
+	m_SolidToPlayers = SOLID_TO_PLAYER_USE_DEFAULT;
+	m_iszDisabledModel = NULL_STRING;
+	m_iszEnabledModel = NULL_STRING;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::UpdateOnRemove( void )
+{
+	m_bDying = true;
+
+	// Remove anything left on me
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(this);
+	if ( pBPInterface && pBPInterface->GetNumObjectsOnMe() )
+	{
+		pBPInterface->RemoveAllObjects();
+	}
+
+	DestroyObject();
+	
+	if ( GetTeam() )
+	{
+		((CTFTeam*)GetTeam())->RemoveObject( this );
+	}
+
+	// Make sure the object isn't in either team's list of objects...
+	Assert( !GetGlobalTFTeam(1)->IsObjectOnTeam( this ) );
+	Assert( !GetGlobalTFTeam(2)->IsObjectOnTeam( this ) );
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseObject::ShouldTransmit( const CCheckTransmitInfo *pInfo )
+{
+	// Always transmit to owner
+	if ( GetBuilder() && pInfo->m_pClientEnt == GetBuilder()->edict() )
+		return FL_EDICT_ALWAYS;
+
+	// Placement models only transmit to owners
+	if ( IsPlacing() )
+		return FL_EDICT_DONTSEND;
+
+	return BaseClass::ShouldTransmit( pInfo );
+}
+
+
+void CBaseObject::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways )
+{
+	// Are we already marked for transmission?
+	if ( pInfo->m_pTransmitEdict->Get( entindex() ) )
+		return;
+
+	BaseClass::SetTransmit( pInfo, bAlways );
+
+	// Force our screens to be sent too.
+	int nTeam = CBaseEntity::Instance( pInfo->m_pClientEnt )->GetTeamNumber();
+	for ( int i=0; i < m_hScreens.Count(); i++ )
+	{
+		CVGuiScreen *pScreen = m_hScreens[i].Get();
+		if ( pScreen && pScreen->IsVisibleToTeam( nTeam ) )
+			pScreen->SetTransmit( pInfo, bAlways );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::Precache()
+{
+	PrecacheVGuiScreen( "screen_basic_with_disable" );
+
+	if ( m_iszUnderAttackSound != NULL_STRING )
+	{
+		PrecacheScriptSound( STRING(m_iszUnderAttackSound) );
+	}
+	PrecacheMaterial( SCREEN_OVERLAY_MATERIAL );
+
+	if ( m_iszDisabledModel != NULL_STRING )
+	{
+		PrecacheModel( STRING( m_iszDisabledModel ) );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::Spawn( void )
+{
+	Precache();
+
+	CollisionProp()->SetSurroundingBoundsType( USE_BEST_COLLISION_BOUNDS );
+	SetSolidToPlayers( m_SolidToPlayers, true );
+
+	m_bWasMapPlaced = false;
+	m_bHasSapper = false;
+	m_takedamage = DAMAGE_YES;
+	m_flHealth = m_iMaxHealth = m_iHealth;
+	m_iAmountPlayerPaidForMe = CalculateObjectCost( GetType(), 0, GetTeamNumber() );
+
+	SetContextThink( BaseObjectThink, gpGlobals->curtime + 0.1, OBJ_BASE_THINK_CONTEXT );
+	m_szAmmoName = NULL;
+
+	AddFlag( FL_OBJECT ); // So NPCs will notice it
+	SetViewOffset( WorldSpaceCenter() - GetAbsOrigin() );
+
+	// Don't take damage if we're invulnerable, and don't require power either
+	if ( m_bInvulnerable )
+	{
+		m_takedamage = DAMAGE_NO;
+		m_fObjectFlags |= OF_DOESNT_NEED_POWER;
+		AddFlag( FL_NOTARGET );
+	}
+
+	// Cache off the normal model name
+	m_iszEnabledModel = GetModelName();
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns information about the various control panels
+//-----------------------------------------------------------------------------
+void CBaseObject::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
+{
+	pPanelName = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Returns information about the various control panels
+//-----------------------------------------------------------------------------
+void CBaseObject::GetControlPanelClassName( int nPanelIndex, const char *&pPanelName )
+{
+	pPanelName = "vgui_screen";
+}
+
+//-----------------------------------------------------------------------------
+// This is called by the base object when it's time to spawn the control panels
+//-----------------------------------------------------------------------------
+void CBaseObject::SpawnControlPanels()
+{
+	char buf[64];
+
+	// FIXME: Deal with dynamically resizing control panels?
+
+	// If we're attached to an entity, spawn control panels on it instead of use
+	CBaseAnimating *pEntityToSpawnOn = this;
+	char *pOrgLL = "controlpanel%d_ll";
+	char *pOrgUR = "controlpanel%d_ur";
+	char *pAttachmentNameLL = pOrgLL;
+	char *pAttachmentNameUR = pOrgUR;
+	if ( IsBuiltOnAttachment() )
+	{
+		pEntityToSpawnOn = dynamic_cast<CBaseAnimating*>((CBaseEntity*)m_hBuiltOnEntity.Get());
+		if ( pEntityToSpawnOn )
+		{
+			char sBuildPointLL[64];
+			char sBuildPointUR[64];
+			Q_snprintf( sBuildPointLL, sizeof( sBuildPointLL ), "bp%d_controlpanel%%d_ll", m_iBuiltOnPoint );
+			Q_snprintf( sBuildPointUR, sizeof( sBuildPointUR ), "bp%d_controlpanel%%d_ur", m_iBuiltOnPoint );
+			pAttachmentNameLL = sBuildPointLL;
+			pAttachmentNameUR = sBuildPointUR;
+		}
+		else
+		{
+			pEntityToSpawnOn = this;
+		}
+	}
+
+	Assert( pEntityToSpawnOn );
+
+	// Lookup the attachment point...
+	int nPanel;
+	for ( nPanel = 0; true; ++nPanel )
+	{
+		Q_snprintf( buf, sizeof( buf ), pAttachmentNameLL, nPanel );
+		int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+		if (nLLAttachmentIndex <= 0)
+		{
+			// Try and use my panels then
+			pEntityToSpawnOn = this;
+			Q_snprintf( buf, sizeof( buf ), pOrgLL, nPanel );
+			nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+			if (nLLAttachmentIndex <= 0)
+				return;
+		}
+
+		Q_snprintf( buf, sizeof( buf ), pAttachmentNameUR, nPanel );
+		int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+		if (nURAttachmentIndex <= 0)
+		{
+			// Try and use my panels then
+			Q_snprintf( buf, sizeof( buf ), pOrgUR, nPanel );
+			nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+			if (nURAttachmentIndex <= 0)
+				return;
+		}
+
+		const char *pScreenName;
+		GetControlPanelInfo( nPanel, pScreenName );
+		if (!pScreenName)
+			continue;
+
+		const char *pScreenClassname;
+		GetControlPanelClassName( nPanel, pScreenClassname );
+		if ( !pScreenClassname )
+			continue;
+
+		// Compute the screen size from the attachment points...
+		matrix3x4_t	panelToWorld;
+		pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
+
+		matrix3x4_t	worldToPanel;
+		MatrixInvert( panelToWorld, worldToPanel );
+
+		// Now get the lower right position + transform into panel space
+		Vector lr, lrlocal;
+		pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
+		MatrixGetColumn( panelToWorld, 3, lr );
+		VectorTransform( lr, worldToPanel, lrlocal );
+
+		float flWidth = lrlocal.x;
+		float flHeight = lrlocal.y;
+
+		CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
+		pScreen->ChangeTeam( GetTeamNumber() );
+		pScreen->SetActualSize( flWidth, flHeight );
+		pScreen->SetActive( false );
+		pScreen->MakeVisibleOnlyToTeammates( true );
+		pScreen->SetOverlayMaterial( SCREEN_OVERLAY_MATERIAL );
+		int nScreen = m_hScreens.AddToTail( );
+		m_hScreens[nScreen].Set( pScreen );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Various commands sent by control panels
+//-----------------------------------------------------------------------------
+void CBaseObject::DismantleCommand( CBaseTFPlayer *pSender )
+{
+	if (CanBeRemovedBy( pSender ))
+	{
+		PickupObject();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::YawCommand( CBaseTFPlayer *pSender, float flYaw )
+{
+	if ( CanBeRotatedBy(pSender) )
+	{
+		QAngle angles = GetAbsAngles();
+
+		angles.y = anglemod( flYaw );
+		SetLocalAngles( ConvertAbsAnglesToLocal( angles ) );
+		Teleport( NULL, &GetLocalAngles(), NULL );
+
+		// Notify the object that it moved
+		ObjectMoved();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::TakeControlCommand( CBaseTFPlayer *pSender )
+{
+	// Deteriorating objects can be bought
+	if ( InSameTeam( pSender ) && IsDeteriorating() )
+	{
+		if ( ClassCanBuild( pSender->PlayerClass(), GetType() ) )
+		{
+			// Make sure he has the resources
+			int iCost = CalculateObjectCost( GetType(), pSender->GetNumObjects( GetType() ), GetTeamNumber() );
+			if ( pSender->GetBankResources() >= iCost )
+			{
+				pSender->RemoveBankResources( iCost );
+				SetBuilder( pSender );
+				pSender->AddObject( this );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Handle commands sent from vgui panels on the client 
+//-----------------------------------------------------------------------------
+bool CBaseObject::ClientCommand( CBaseTFPlayer *pSender, const char *pCmd, ICommandArguments *pArg )
+{
+	if ( FStrEq( pCmd, "dismantle" ) )
+	{
+		DismantleCommand( pSender );
+		return true;
+	}
+
+	if ( FStrEq( pCmd, "yaw" ) )
+	{
+		if ( pArg->Argc() == 2 )
+		{
+			float flYaw = atof( pArg->Argv(1) );
+			YawCommand( pSender, flYaw );
+		}
+		return true;
+	}
+
+	if ( FStrEq( pCmd, "takecontrol" ) )
+	{
+		TakeControlCommand( pSender );
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::BaseObjectThink( void )
+{
+	SetNextThink( gpGlobals->curtime + 0.1, OBJ_BASE_THINK_CONTEXT );
+
+	// Make sure animation is up to date
+	DetermineAnimation();
+
+	// Can't animate without a model
+	if ( !(m_fObjectFlags & OF_DOESNT_HAVE_A_MODEL) )
+	{
+		StudioFrameAdvance();
+	}
+
+	/*
+	ROBIN: Hierarchy should do this for us
+
+	// If we were built on an attachment that's moved, update our position
+	if ( !IsPlacing() && IsBuiltOnAttachment() )
+	{
+		IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>((CBaseEntity*)m_hBuiltOnEntity);
+		Assert( pBPInterface );
+
+		if ( pBPInterface->ShouldCheckForMovement() )
+		{
+			Vector vecOrigin;
+			QAngle vecAngles;
+			pBPInterface->GetBuildPoint( m_iBuiltOnPoint, vecOrigin, vecAngles );
+
+			EntityMatrix vehicleToWorld, childMatrix;
+			vehicleToWorld.InitFromEntity( GetMoveParent() ); // parent->world
+			vecOrigin = vehicleToWorld.WorldToLocal( vecOrigin );
+
+			if ( vecOrigin != GetLocalOrigin() )
+			{
+				Teleport( &vecOrigin, NULL, NULL );
+			}
+		}
+	}
+	*/
+
+	// Do nothing while we're being placed
+	if ( IsPlacing() )
+	{
+		for ( int i=0; i < m_aRopes.Count(); i++ )
+		{
+			if ( m_aRopes[i].Get() )
+				m_aRopes[i]->SetupHangDistance( ROPE_HANG_DIST );
+		}
+
+		return;
+	}
+
+	// If we're deteriorating, keep going
+	if ( IsDeteriorating() )
+	{
+		DeterioratingThink();
+	}
+
+	// If we're building, keep going
+	if ( IsBuilding() )
+	{
+		BuildingThink();
+		return;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CBaseObject::GetOwner()
+{ 
+	return m_hBuilder; 
+}
+
+
+//-----------------------------------------------------------------------------
+// Do we have to be built in a resource zone?
+//-----------------------------------------------------------------------------
+bool CBaseObject::MustBeBuiltInResourceZone( void ) const
+{
+	return (m_fObjectFlags & OF_MUST_BE_BUILT_IN_RESOURCE_ZONE) != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseObject::MustBeBuiltInConstructionYard( ) const
+{
+	return (m_fObjectFlags & OF_MUST_BE_BUILT_IN_CONSTRUCTION_YARD) != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseObject::MustNotBeBuiltInConstructionYard( void ) const
+{
+	return !MustBeBuiltInConstructionYard();
+}
+
+//-----------------------------------------------------------------------------
+// Do we have to be built on an attachment point
+//-----------------------------------------------------------------------------
+bool CBaseObject::MustBeBuiltOnAttachmentPoint( void ) const
+{
+	return (m_fObjectFlags & OF_MUST_BE_BUILT_ON_ATTACHMENT) != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Map placed objects need to setup here.
+//-----------------------------------------------------------------------------
+void CBaseObject::InitializeMapPlacedObject( void )
+{
+	m_bWasMapPlaced = true;
+	m_fObjectFlags |= OF_CANNOT_BE_DISMANTLED;
+
+	// If a map-placed object spawns child objects with their own control
+	// panels, all of this lovely code will already have been run
+	if (m_hBuiltOnEntity.Get())
+		return;
+
+	SetBuilder( NULL );
+
+	// NOTE: We must spawn the control panels now, instead of during
+	// Spawn, because until placement is started, we don't actually know
+	// the position of the control panel because we don't know what it's
+	// been attached to (could be a vehicle which supplies a different
+	// place for the control panel)
+
+	if ( !(m_fObjectFlags & OF_DOESNT_HAVE_A_MODEL) )
+	{
+		SpawnControlPanels();
+	}
+
+	SetHealth( GetMaxHealth() );
+
+	AlignToGround( GetAbsOrigin() );
+	FinishedBuilding();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::Activate( void )
+{
+	BaseClass::Activate();
+
+	// Add myself to the team
+	InitializeMapPlacedObject();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetBuilder( CBaseTFPlayer *pBuilder, bool moveobjects )
+{
+	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseObject::SetBuilder builder %s, moveobjects == %s\n", gpGlobals->curtime, 
+		pBuilder ? pBuilder->GetPlayerName() : "NULL", 
+		moveobjects ? "true" : "false" ) );
+
+	ChangeBuilder( pBuilder, moveobjects );
+}
+
+
+//-----------------------------------------------------------------------------
+// Called when the builder rotates this object...
+//-----------------------------------------------------------------------------
+void CBaseObject::ObjectMoved( )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CBaseObject::ObjectType( ) const
+{
+	return m_iObjectType;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove this object from it's team and mark for deletion
+//-----------------------------------------------------------------------------
+void CBaseObject::DestroyObject( void )
+{
+	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseObject::DestroyObject %p:%s\n", gpGlobals->curtime, this, GetClassname() ) );
+
+	COrderEvent_ObjectDestroyed order( this );
+	GlobalOrderEvent( &order );
+
+	if ( GetBuilder() )
+	{
+		GetBuilder()->OwnedObjectDestroyed( this );
+	}
+
+	// Tell my powerpack that I'm gone
+	if ( m_hPowerPack != NULL )
+	{
+		m_hPowerPack->UnPowerObject( this );
+	}
+
+	// Tell my power up source that I have been destroyed.
+	if ( GetBuffStation() )
+	{
+		GetBuffStation()->DeBuffObject( this );
+	}
+
+	// Detach all my ropes
+	int i;
+	for ( i = 0; i < m_aRopes.Size(); i++ )
+	{
+		if ( m_aRopes[i] )
+		{
+			m_aRopes[i]->DieAtNextRest();
+		}
+	}
+
+	UTIL_Remove( this );
+
+	// Kill the control panels
+	for ( i = m_hScreens.Count(); --i >= 0; )
+	{
+		DestroyVGuiScreen( m_hScreens[i].Get() );
+	}
+	m_hScreens.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: My builder's switched class/team, so start deteriorating.
+//-----------------------------------------------------------------------------
+void CBaseObject::StartDeteriorating( void )
+{
+	if ( tf_fastbuild.GetInt() )
+		return;
+
+	m_bDeteriorating = true;
+	m_flStartedDeterioratingAt = gpGlobals->curtime;
+	SetBuilder( NULL, true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::StopDeteriorating( void )
+{
+	m_bDeteriorating = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Continue deterioration of this object
+//-----------------------------------------------------------------------------
+void CBaseObject::DeterioratingThink( void )
+{
+	// Calculate damage. The longer we've lasted, the faster we should go.
+	float flDamage;
+	float flDeteriorationTime = (gpGlobals->curtime - m_flStartedDeterioratingAt);
+	// If we've lasted less than the base time, we want to take the base time to die
+	flDamage = 0.1 * ( GetMaxHealth() / object_deterioration_time.GetFloat() ) * ceil(flDeteriorationTime / object_deterioration_time.GetFloat());
+	// Hax0r the damage to get around the object damage reduction
+	if ( obj_damage_factor.GetFloat() )
+	{
+		flDamage *= 1 / obj_damage_factor.GetFloat();
+	}
+
+	// Apply the damage
+	OnTakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), flDamage, DMG_GENERIC ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the total time it will take to build this object
+//-----------------------------------------------------------------------------
+float CBaseObject::GetTotalTime( void )
+{
+	if (tf_fastbuild.GetInt())
+		return 2.f;
+
+	// If it's in a construction yard, don't take more than 5 seconds to build
+  	if ( PointInConstructionYard( GetAbsOrigin() ) )
+  	{
+		if ( GetObjectInfo( ObjectType() )->m_flBuildTime > 5.0 )
+  			return 5.0;
+  	}
+
+	return GetObjectInfo( ObjectType() )->m_flBuildTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start placing the object
+//-----------------------------------------------------------------------------
+void CBaseObject::StartPlacement( CBaseTFPlayer *pPlayer )
+{
+	AddSolidFlags( FSOLID_NOT_SOLID );
+
+	m_bPlacing = true;
+	m_bBuilding = false;
+	if ( pPlayer )
+	{
+		SetBuilder( pPlayer );
+		ChangeTeam( pPlayer->GetTeamNumber() );
+	}
+
+	// Make it semi-transparent
+	m_nRenderMode = kRenderTransAlpha; 
+	SetRenderColorA( 128 );
+
+	// Set my build size
+	CollisionProp()->WorldSpaceAABB( &m_vecBuildMins, &m_vecBuildMaxs );
+	m_vecBuildMins -= Vector( 4,4,0 );
+	m_vecBuildMaxs += Vector( 4,4,0 );
+	m_vecBuildMins -= GetAbsOrigin();
+	m_vecBuildMaxs -= GetAbsOrigin();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop placing the object
+//-----------------------------------------------------------------------------
+void CBaseObject::StopPlacement( void )
+{
+	UTIL_Remove( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find the nearest buildpoint on the specified entity
+//-----------------------------------------------------------------------------
+bool CBaseObject::FindNearestBuildPoint( CBaseEntity *pEntity, Vector vecBuildOrigin, float &flNearestPoint, Vector &vecNearestBuildPoint )
+{
+	bool bFoundPoint = false;
+
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(pEntity);
+	Assert( pBPInterface );
+
+	// Any empty buildpoints?
+	for ( int i = 0; i < pBPInterface->GetNumBuildPoints(); i++ )
+	{
+		// Can this object build on this point?
+		if ( pBPInterface->CanBuildObjectOnBuildPoint( i, GetType() ) )
+		{
+			// Close to this point?
+			Vector vecBPOrigin;
+			QAngle vecBPAngles;
+			if ( pBPInterface->GetBuildPoint(i, vecBPOrigin, vecBPAngles) )
+			{
+				float flDist = (vecBPOrigin - vecBuildOrigin).Length();
+				if ( flDist < MIN(flNearestPoint, pBPInterface->GetMaxSnapDistance( i )) )
+				{
+					flNearestPoint = flDist;
+					vecNearestBuildPoint = vecBPOrigin;
+					m_hBuiltOnEntity = pEntity;
+					m_iBuiltOnPoint = i;
+
+					// Set our angles to the buildpoint's angles
+					SetAbsAngles( vecBPAngles );
+
+					bFoundPoint = true;
+				}
+			}
+		}
+	}
+
+	return bFoundPoint;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate the placement model's position
+//-----------------------------------------------------------------------------
+bool CBaseObject::CalculatePlacement( CBaseTFPlayer *pPlayer )
+{
+	// Calculate build position
+	Vector forward;
+	QAngle vecAngles = vec3_angle;
+	vecAngles.y = pPlayer->EyeAngles().y;
+	SetLocalAngles( vecAngles );
+	AngleVectors(vecAngles, &forward );
+
+	// Adjust build distance based upon object size
+	Vector2D xyDims;
+	xyDims.x = MAX( fabs( m_vecBuildMins.x ), fabs( m_vecBuildMaxs.x ) );
+	xyDims.y = MAX( fabs( m_vecBuildMins.y ), fabs( m_vecBuildMaxs.y ) );
+	float flDistance = xyDims.Length() + 16; // small safety buffer
+	Vector vecBuildOrigin = pPlayer->WorldSpaceCenter() + forward * flDistance;
+
+	bool bSnappedToPoint = false;
+	bool bShouldAttachToParent = false;
+
+	// See if there are any nearby build positions to snap to
+	Vector vecNearestBuildPoint = vec3_origin;
+	float flNearestPoint = 9999;
+	// First, look for nearby buildpoints on other objects
+	for ( int i = 0; i < GetTFTeam()->GetNumObjects(); i++ )
+	{
+		CBaseObject *pObject = GetTFTeam()->GetObject(i);
+		if ( pObject && !pObject->IsPlacing() )
+		{
+			if ( FindNearestBuildPoint( pObject, vecBuildOrigin, flNearestPoint, vecNearestBuildPoint ) )
+			{
+				bSnappedToPoint = true;
+
+				// If I'm a vehicle, I'm being built on an MCV. Don't attach to the parent.
+				if ( ShouldAttachToParent() )
+				{
+					bShouldAttachToParent = true;
+				}
+			}
+		}
+	}
+
+	// If we're a vehicle, look for vehicle build points
+	if ( IsAVehicle() )
+	{
+		CBaseEntity *pEntity = NULL;
+		while ((pEntity = gEntList.FindEntityByClassname( pEntity, "info_vehicle_bay" )) != NULL)
+		{
+			if ( FindNearestBuildPoint( pEntity, vecBuildOrigin, flNearestPoint, vecNearestBuildPoint ) )
+			{
+				bSnappedToPoint = true;
+			}
+		}
+	}
+
+	// Check for resource zones for resource pumps
+	if ( GetType() == OBJ_RESOURCEPUMP )
+	{
+		CBaseEntity *pEntity = NULL;
+		while ((pEntity = gEntList.FindEntityByClassname( pEntity, "trigger_resourcezone" )) != NULL)
+		{
+			if ( FindNearestBuildPoint( pEntity, vecBuildOrigin, flNearestPoint, vecNearestBuildPoint ) )
+			{
+				bSnappedToPoint = true;
+			}
+		}
+	}
+
+	// See if there's any mapdefined build points near me
+	int iCount = g_MapDefinedBuildPoints.Count();
+	for ( i = 0; i < iCount; i++ )
+	{
+		if ( !InSameTeam(g_MapDefinedBuildPoints[i]) )
+			continue;
+
+		if ( FindNearestBuildPoint( g_MapDefinedBuildPoints[i], vecBuildOrigin, flNearestPoint, vecNearestBuildPoint ) )
+		{
+			bSnappedToPoint = true;
+		}
+	}
+
+	// Upgrades become invisible if the player's not attaching them to a snap pint
+	if ( IsAnUpgrade() )
+	{
+		if ( MustBeBuiltOnAttachmentPoint() && !bSnappedToPoint )
+		{
+			AddEffects( EF_NODRAW );
+			return false;
+		}
+		else
+		{
+			RemoveEffects( EF_NODRAW );
+		}
+	}
+
+	// Did we find a snap point?
+	if ( bSnappedToPoint )
+	{
+		if ( bShouldAttachToParent )
+		{
+			AttachObjectToObject( m_hBuiltOnEntity.Get(), m_iBuiltOnPoint, vecNearestBuildPoint );
+		}
+
+		return CheckBuildOrigin( pPlayer, vecNearestBuildPoint, true );
+	}
+
+	// Clear out previous parent 
+	if ( m_hBuiltOnEntity.Get() )
+	{
+		m_hBuiltOnEntity = NULL;
+		m_iBuiltOnPoint = 0;
+		SetParent( NULL );
+
+		SetupUnattachedVersion();
+	}
+
+	// Check the build position
+	return CheckBuildOrigin( pPlayer, vecBuildOrigin, false );
+}
+
+
+bool CBaseObject::VerifyCorner( const Vector &vBottomCenter, float xOffset, float yOffset )
+{
+	Vector vStart( vBottomCenter.x + xOffset, vBottomCenter.y + yOffset, vBottomCenter.z );
+	
+	trace_t tr;
+	UTIL_TraceLine( 
+		vStart, 
+		vStart - Vector( 0, 0, tf_obj_ground_clearance.GetFloat() ), 
+		MASK_SOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
+	
+	return !tr.startsolid && tr.fraction < 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check under a build point to ensure it's buildable on
+//-----------------------------------------------------------------------------
+bool CBaseObject::CheckBuildPoint( Vector vecPoint, Vector &vecTrace, Vector *vecOutPoint )
+{
+	trace_t tr;
+
+	bool bClear = true;
+	Vector vecEnd;
+
+	// Ensure that this point isn't in a no-build zone:
+	if( !tf_fastbuild.GetInt() && NoBuildPreventsBuild(this, vecPoint ) )
+		bClear = false;
+
+	// If the point isn't in solid, trace down until we find the ground
+	if ( enginetrace->GetPointContents( vecPoint ) == CONTENTS_EMPTY )
+	{
+		vecEnd = vecPoint - vecTrace;
+		UTIL_TraceLine( vecPoint, vecEnd, MASK_SOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr);
+
+		// Can't find ground to build on?
+		if ( tr.fraction == 1.0 )
+		{
+			bClear = false;
+		}
+	} 
+	else
+	{
+		// If the point's solid, trace up until we find empty air
+		vecEnd = vecPoint + vecTrace;
+		UTIL_TraceLine( vecPoint, vecEnd, MASK_SOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr);
+
+		// Can't find ground to build on?
+		if ( tr.allsolid )
+		{
+			bClear = false;
+		}
+	}
+
+	// FIXME: HACK! This is a test to try to make mud non-buildable!!
+	const surfacedata_t *pSurfaceProp = physprops->GetSurfaceData( tr.surface.surfaceProps );
+	if (pSurfaceProp->game.maxSpeedFactor < 1.0f)
+		bClear = false;
+
+	if ( vecOutPoint )
+	{
+		*vecOutPoint = tr.endpos;
+	}
+
+	return bClear;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+bool CBaseObject::CheckBuildOrigin( CBaseTFPlayer *pPlayer, const Vector &vecInitialBuildOrigin, bool bSnappedToPoint )
+{
+	// By default, use the vecBuildOrigin..
+	bool bResult = true;
+	m_vecBuildOrigin = vecInitialBuildOrigin;
+	Vector vErrorOrigin = vecInitialBuildOrigin - (m_vecBuildMaxs - m_vecBuildMins) * 0.5f - m_vecBuildMins;
+
+	// If we're snapping to a build point, don't bother performing area checks
+	if ( !bSnappedToPoint )
+	{
+		Vector vBuildDims = m_vecBuildMaxs - m_vecBuildMins;
+		Vector vHalfBuildDims = vBuildDims * 0.5;
+		Vector vHalfBuildDimsXY( vHalfBuildDims.x, vHalfBuildDims.y, 0 );
+
+		// Here, we start at the highest Z we'll allow for the top of the object. Then
+		// we sweep an XY cross section downwards until it hits the ground.
+		//
+		// The rule is that the top of to box can't go lower than the player's feet, and the bottom of the
+		// box can't go higher than the player's head.
+		//
+		// To simplify things in here, we treat the box as though it's symmetrical about all axes
+		// (so mins = -maxs), then reoffset the box at the very end.
+		Vector vHalfPlayerDims = (pPlayer->WorldAlignMaxs() - pPlayer->WorldAlignMins()) * 0.5f;
+		float flBoxTopZ = pPlayer->WorldSpaceCenter().z + vHalfPlayerDims.z + vBuildDims.z;
+		float flBoxBottomZ = pPlayer->WorldSpaceCenter().z - vHalfPlayerDims.z - vBuildDims.z;
+		
+		// First, find the ground (ie: where the bottom of the box goes).
+		trace_t tr;
+		float bottomZ = 0;
+		int nIterations = 6;
+		float topZ = flBoxTopZ;
+		float topZInc = (flBoxBottomZ - flBoxTopZ) / (nIterations-1);
+		for ( int iIteration = 0; iIteration < nIterations; iIteration++ )
+		{
+			UTIL_TraceHull( 
+				Vector( m_vecBuildOrigin.x, m_vecBuildOrigin.y, topZ ), 
+				Vector( m_vecBuildOrigin.x, m_vecBuildOrigin.y, flBoxBottomZ ), 
+				-vHalfBuildDimsXY, vHalfBuildDimsXY, MASK_SOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
+			bottomZ = tr.endpos.z;
+
+			// If there is no ground, then we can't place here.
+			if ( tr.fraction == 1 )
+			{
+				m_vecBuildOrigin = vErrorOrigin;
+				return false;
+			}
+
+			// If it started in solid, keep moving down.
+			// Note that a working CGameTrace::fractionleftsolid would make this trivial, but it isn't
+			// working now so we must resort to rubitry.
+			if ( !tr.startsolid )
+				break;
+
+			topZ += topZInc;
+		}
+		
+		if ( iIteration == nIterations )
+		{
+			m_vecBuildOrigin = vErrorOrigin;
+			return false;
+		}
+
+
+		// Now see if the range we've got leaves us room for our box.
+		if ( topZ - bottomZ < vBuildDims.z )
+		{
+			m_vecBuildOrigin = vErrorOrigin;
+			return false;
+		}
+
+		// Verify that it's not on too much of a slope by seeing how far the corners are from the ground.
+		Vector vBottomCenter( m_vecBuildOrigin.x, m_vecBuildOrigin.y, bottomZ );
+		if ( !VerifyCorner( vBottomCenter, -vHalfBuildDims.x, -vHalfBuildDims.y ) ||
+			 !VerifyCorner( vBottomCenter, +vHalfBuildDims.x, +vHalfBuildDims.y ) ||
+			 !VerifyCorner( vBottomCenter, +vHalfBuildDims.x, -vHalfBuildDims.y ) ||
+			 !VerifyCorner( vBottomCenter, -vHalfBuildDims.x, +vHalfBuildDims.y ) )
+		{
+			m_vecBuildOrigin = vErrorOrigin;
+			return false;
+		}
+
+		// Ok, now we know the Z range where this box can fit.
+		Vector vBottomLeft = m_vecBuildOrigin - vHalfBuildDims;
+		vBottomLeft.z = bottomZ;
+		m_vecBuildOrigin = vBottomLeft - m_vecBuildMins;
+	}
+
+	Vector vecForward, vecRight, vecUp;
+	AngleVectors( GetLocalAngles(), &vecForward, &vecRight, &vecUp );
+	AttemptToFindPower();
+	AttemptToFindBuffStation();
+
+	// Make sure construction yards don't screw us up (tf_fastbuild allows builds anywhere)
+	if ( !tf_fastbuild.GetInt() && ConstructionYardPreventsBuild( this, m_vecBuildOrigin ))
+		return false;
+
+	// If we have to be attached to something, and we're not, abort
+	if ( !tf_fastbuild.GetInt() && MustBeBuiltOnAttachmentPoint() && !bSnappedToPoint )
+		return false;
+
+	// Make sure there aren't any solid objects in the area
+	if ( !bSnappedToPoint || IsAVehicle() )
+	{
+		if ( !(m_fObjectFlags & OF_DONT_PREVENT_BUILD_NEAR_OBJ) )
+		{
+			// Get a list of nearby entities
+			CBaseEntity *pListOfNearbyEntities[100];
+			int iNumberOfNearbyEntities = UTIL_EntitiesInSphere( pListOfNearbyEntities, 100, m_vecBuildOrigin, GetNearbyObjectCheckRadius(), 0 );
+			for ( int i = 0; i < iNumberOfNearbyEntities; i++ )
+			{
+				CBaseEntity *pEntity = pListOfNearbyEntities[i];
+				if ( pEntity->IsSolid( ) )
+				{
+					// Ignore shields..
+					if ( pEntity->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD )
+						continue;
+
+					// Ignore func brushes
+					// BUGBUG: Shouldn't this test against MOVETYPE_PUSH instead of SOLID_BSP?
+					if ( pEntity->GetSolid() == SOLID_BSP )
+						continue;
+
+					// Ignore the player who's building
+					if ( pEntity == GetBuilder() )
+						continue;
+
+					// YWB:  Ignore other players
+					if ( pEntity->IsPlayer() )
+						continue;
+
+					// Ignore map placed objects
+					if ( pEntity->GetTeamNumber() == 0 )
+						continue;
+				
+					//NDebugOverlay::EntityBounds( pEntity, 0,255,0,8, 0.1 );
+					return false;
+				}
+
+				// Sentryguns may be turtled, and non-solid
+				if ( pEntity->Classify() == CLASS_MILITARY )
+				{
+					CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>(pEntity);
+					if ( pSentry && pSentry->IsTurtled() )
+						return false;
+				}
+			}
+		}
+	}
+
+	if ( !bSnappedToPoint )
+	{
+		AlignToGround( m_vecBuildOrigin );
+	}
+
+	return bResult;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Align myself to the ground below the specified point
+//-----------------------------------------------------------------------------
+void CBaseObject::AlignToGround( Vector vecOrigin )
+{
+	if ( !(m_fObjectFlags & OF_ALIGN_TO_GROUND) )
+		return;
+
+	trace_t tr;
+	Vector vecWorldMins, vecWorldMaxs;
+	CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs );
+	float flHeight = MAX( vecWorldMaxs.z - vecWorldMins.z, 60 );
+	UTIL_TraceLine( vecOrigin, vecOrigin + Vector(0,0,-flHeight), MASK_SOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
+	if ( tr.fraction != 1.0 )
+	{
+		// Orient the *up* axis to be along the plane normal
+		Vector perp( 1, 0, 0 );
+		Vector forward, right;
+		CrossProduct( perp, tr.plane.normal, forward );
+		if (forward.LengthSqr() < 0.1f)
+		{
+			perp.Init( 0, 1, 0 );
+			CrossProduct( perp, tr.plane.normal, forward );
+		}
+		VectorNormalize( forward );
+		CrossProduct( tr.plane.normal, forward, right );
+
+		VMatrix orientation( forward, right, tr.plane.normal );
+
+		QAngle angles;
+		MatrixToAngles( orientation, angles );
+		SetAbsAngles( angles );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Exit points for mounted vehicles....
+//-----------------------------------------------------------------------------
+void CBaseObject::GetExitPoint( CBaseEntity *pPlayer, int nBuildPoint, Vector *pAbsPosition, QAngle *pAbsAngles )
+{
+	// Deal with hierarchy...
+	IHasBuildPoints *pMount = dynamic_cast<IHasBuildPoints*>(GetMoveParent());
+	if (pMount)
+	{
+		int nBuildPoint = pMount->FindObjectOnBuildPoint( this );
+		if (nBuildPoint >= 0)
+		{
+			pMount->GetExitPoint( pPlayer, nBuildPoint, pAbsPosition, pAbsAngles );
+			return;
+		}
+	}
+
+	// FIXME: In future, we may well want to use specific exit attachments here...
+	GetBuildPoint( nBuildPoint, *pAbsPosition, *pAbsAngles );
+
+	// Move back along the forward direction a bit...
+	Vector vecForward, vecUp;
+	AngleVectors( *pAbsAngles, &vecForward, NULL, &vecUp );
+	*pAbsPosition -= vecForward * 60;
+	*pAbsPosition += vecUp * 30;
+
+	// Now select a good spot to drop onto
+	Vector vNewPos;
+	if ( !EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
+	{
+		Warning("Can't find valid place to exit object.\n");
+		return;
+	}
+
+	*pAbsPosition = vNewPos;
+}
+
+
+void CBaseObject::AdjustInitialBuildAngles()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Try and find power for this object during placement
+//-----------------------------------------------------------------------------
+void CBaseObject::AttemptToFindPower( void )
+{
+	// Human objects need power, so show the player if the current position will have power, but don't prevent building.
+	if ( !CanPowerupEver( POWERUP_POWER ) )
+		return;
+
+	// If I have a powerpack, see if I'm unable to keep power, or not needed.
+	// This is done before checking to see if the object needs power, because it may
+	// have once needed power, but doesn't anymore (i.e. snapped to an attachment point)
+	if ( m_hPowerPack )
+	{
+		m_hPowerPack->EnsureObjectPower( this );
+	}
+
+	// If I don't have a powerpack, or I just moved too far from it, look for a powerpack
+	if ( !m_hPowerPack )
+	{
+		GetTFTeam()->UpdatePowerpacks( NULL, this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBaseObject::AttemptToFindBuffStation( void )
+{
+	// Check to see if this object can be connected to a buff station.
+	if ( !CanBeHookedToBuffStation() )
+		return;
+
+	// We have already found a buff station, we want to use - check distances.
+	if ( GetBuffStation() )
+	{
+		GetBuffStation()->CheckBuffConnection( this );
+	}
+	// Look for a buff station to use.
+	else
+	{
+		GetTFTeam()->UpdateBuffStations( NULL, this, true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Move the placement model to the current position. Return false if it's an invalid position
+//-----------------------------------------------------------------------------
+bool CBaseObject::UpdatePlacement( CBaseTFPlayer *pPlayer )
+{
+	bool placementOk = CalculatePlacement( pPlayer );
+	if ( placementOk )
+	{
+		SetRenderColor( 255, 255, 255, GetRenderColor().a );
+	}
+	else
+	{
+		SetRenderColor( 255, 0, 0, GetRenderColor().a );
+	}
+
+	Teleport( &m_vecBuildOrigin, &GetLocalAngles(), NULL );
+
+	return placementOk;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseObject::PreStartBuilding()
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start building the object
+//-----------------------------------------------------------------------------
+bool CBaseObject::StartBuilding( CBaseEntity *pBuilder )
+{
+	// Need to add the object to the team now...
+	CTFTeam *pTFTeam = ( CTFTeam * )GetGlobalTeam( GetTeamNumber() );
+
+	// Deduct the cost from the player
+	if ( pBuilder && pBuilder->IsPlayer() )
+	{
+		m_iAmountPlayerPaidForMe = ((CBaseTFPlayer*)pBuilder)->StartedBuildingObject( m_iObjectType );
+		if ( !m_iAmountPlayerPaidForMe )
+		{
+			// Player couldn't afford to pay for me, so abort
+			ClientPrint( (CBasePlayer*)pBuilder, HUD_PRINTCENTER, "Not enough resources.\n" );
+			StopPlacement();
+			return false;
+		}
+	}
+	
+	// Add this object to the team's list (because we couldn't add it during
+	// placement mode)
+	if ( pTFTeam && !pTFTeam->IsObjectOnTeam( this ) )
+	{
+		pTFTeam->AddObject( this );
+	}
+
+	m_bPlacing = false;
+	m_bBuilding = true;
+	SetHealth( OBJECT_CONSTRUCTION_STARTINGHEALTH );
+	m_flPercentageConstructed = 0;
+
+	// Compute a good fitting AABB since we know where this thing belongs
+	if ( VPhysicsGetObject() && !IsBuiltOnAttachment() )
+	{
+		Vector absmins, absmaxs;		
+		physcollision->CollideGetAABB( &absmins, &absmaxs, VPhysicsGetObject()->GetCollide(), GetAbsOrigin(), GetAbsAngles() );
+
+		// This is required to get the client + server looking the same
+		// since the client uses the mins to compute absmins + absmaxs
+		SetCollisionBounds( absmins - GetAbsOrigin(), absmaxs - GetAbsOrigin() );
+	}
+
+	m_nRenderMode = kRenderNormal; 
+	RemoveSolidFlags( FSOLID_NOT_SOLID );
+
+	// NOTE: We must spawn the control panels now, instead of during
+	// Spawn, because until placement is started, we don't actually know
+	// the position of the control panel because we don't know what it's
+	// been attached to (could be a vehicle which supplies a different
+	// place for the control panel)
+	// NOTE: We must also spawn it before FinishedBuilding can be called
+	SpawnControlPanels();
+
+	// Tell the object we've been built on that we exist
+	if ( IsBuiltOnAttachment() && ShouldAttachToParent() )
+	{
+		IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>((CBaseEntity*)m_hBuiltOnEntity.Get());
+		Assert( pBPInterface );
+		pBPInterface->SetObjectOnBuildPoint( m_iBuiltOnPoint, this );
+	}
+
+	// Start the build animations
+	m_flTotalConstructionTime = m_flConstructionTimeLeft = GetTotalTime();
+
+	if ( pBuilder && pBuilder->IsPlayer() )
+	{
+		((CBaseTFPlayer*)pBuilder)->FinishedObject( this );
+	}
+
+	m_vecBuildOrigin = GetAbsOrigin();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Continue construction of this object
+//-----------------------------------------------------------------------------
+void CBaseObject::BuildingThink( void )
+{
+	// Continue construction
+	Repair( (GetMaxHealth() - OBJECT_CONSTRUCTION_STARTINGHEALTH) / m_flTotalConstructionTime * OBJECT_CONSTRUCTION_INTERVAL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::AttemptToActivateBuffStation( void )
+{
+	if ( !GetBuffStation() )
+		return;
+
+	if ( GetBuffStation()->IsPlacing() || GetBuffStation()->IsBuilding() ||
+		 !GetBuffStation()->IsPowered() )
+		return;
+
+	if ( m_bBuffActivated )
+		return;
+
+	BuffStationActivate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetControlPanelsActive( bool bState )
+{
+	// Activate control panel screens
+	for ( int i = m_hScreens.Count(); --i >= 0; )
+	{
+		if (m_hScreens[i].Get())
+		{
+			m_hScreens[i]->SetActive( bState );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::FinishedBuilding( void )
+{
+	SetControlPanelsActive( true );
+
+	// Only make a shadow if the object doesn't use vphysics
+	if (!VPhysicsGetObject())
+	{
+		VPhysicsInitStatic();
+	}
+
+	m_bBuilding = false;
+
+	AttemptToGoActive();
+	AttemptToActivateBuffStation();
+
+	// We're done building, add in the stat...
+	TFStats()->IncrementStat( (TFStatId_t)(TF_STAT_FIRST_OBJECT_BUILT + ObjectType()), 1 );
+
+	// Spawn any objects on this one
+	SpawnObjectPoints();
+
+	// Let our vehicle bay know, if we have one
+	if ( m_hVehicleBay )
+	{
+		m_hVehicleBay->FinishedBuildVehicle( this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Objects store health in hacky ways
+//-----------------------------------------------------------------------------
+void CBaseObject::SetHealth( float flHealth )
+{
+	if ( IsDisabled() )
+	{
+		if ( ( m_flMinDisableHealth != 0.0f && flHealth > m_flMinDisableHealth ) ||
+			 ( flHealth > 1 ) )
+		{
+			// Reenable and fire output
+			SetDisabled( false );
+
+			m_OnBecomingReenabled.FireOutput( this, this );
+		}
+	}
+
+	bool changed = m_flHealth != flHealth;
+
+	m_flHealth = flHealth;
+	m_iHealth = ceil(m_flHealth);
+
+	// If we have a model, and a pose parameter, set the pose parameter to reflect our health
+	if ( !(m_fObjectFlags & OF_DOESNT_HAVE_A_MODEL) )
+	{
+		if (LookupPoseParameter( "object_health") >= 0 && GetMaxHealth() > 0 )
+		{
+			SetPoseParameter( "object_health", 100 * ( GetHealth() / (float)GetMaxHealth() ) );
+		}
+	}
+
+	if ( changed )
+	{
+		// Set value and fire output
+		m_OnObjectHealthChanged.Set( m_flHealth, this, this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just started
+//-----------------------------------------------------------------------------
+void CBaseObject::PowerupStart( int iPowerup, float flAmount, CBaseEntity *pAttacker, CDamageModifier *pDamageModifier )
+{
+	switch( iPowerup )
+	{
+	case POWERUP_BOOST:
+		{
+			// Can we boost health further?
+			if ( GetHealth() < GetMaxHealth() )
+			{
+				/*
+				if ( (gpGlobals->curtime - m_flLastRepairTime) > 0.01 )
+				{
+					Msg("TOTAL REPAIR: %.2f in %.2f\n\n", m_flRepairedSinceLastTime, (gpGlobals->curtime - m_flLastRepairTime) );
+				}
+
+				if ( pAttacker->IsPlayer() )
+				{
+					CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pAttacker;
+					Msg("(%.2f) %s repaired %s for %.2f health.\n", gpGlobals->curtime, pPlayer->GetPlayerName(), GetClassname(), flAmount );
+				}
+				*/
+				// Is this repair happening at the same time as other repairing on me?
+				if ( (gpGlobals->curtime - m_flLastRepairTime) < 0.01 )
+				{
+					//Msg("  ->Reducing repair by %.2f\n", m_flNextRepairMultiplier );
+					flAmount *= m_flNextRepairMultiplier;
+					m_flNextRepairMultiplier *= 0.5;
+				}
+				else
+				{
+					m_flLastRepairTime = gpGlobals->curtime;
+					m_flNextRepairMultiplier = 0.5;
+					m_flRepairedSinceLastTime = 0;
+				}
+
+				//Msg("  REPAIRED: %.2f\n", flAmount );
+
+				Repair( flAmount );
+
+				m_flRepairedSinceLastTime += flAmount;
+			}
+
+			// Prevent callback to base class, since we handled it here
+			return;
+		}
+		break;
+
+	case POWERUP_POWER:
+		{
+			Assert( m_hPowerPack );
+			AttemptToGoActive();
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	BaseClass::PowerupStart( iPowerup, flAmount, pAttacker, pDamageModifier );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just started
+//-----------------------------------------------------------------------------
+void CBaseObject::PowerupEnd( int iPowerup )
+{
+	switch( iPowerup )
+	{
+	case POWERUP_POWER:
+		{
+			OnGoInactive();
+			m_hPowerPack = NULL;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	BaseClass::PowerupEnd( iPowerup );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Override base traceattack to prevent visible effects from team members shooting me
+//-----------------------------------------------------------------------------
+void CBaseObject::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr )
+{
+	// Prevent team damage here so blood doesn't appear
+	if ( inputInfo.GetAttacker() )
+	{
+		if ( InSameTeam(inputInfo.GetAttacker()) )
+			return;
+	}
+
+	float fVulnerableMultiplier = FindVulnerablePointMultiplier( ptr->hitgroup, ptr->hitbox ); 
+
+	CTakeDamageInfo info = inputInfo;
+	info.ScaleDamage( fVulnerableMultiplier );
+
+	SpawnBlood( ptr->endpos, vecDir, BloodColor(), info.GetDamage() );
+	AddMultiDamage( info, this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Prevent Team Damage
+//-----------------------------------------------------------------------------
+ConVar object_show_damage( "obj_show_damage", "0", 0, "Show all damage taken by objects." );
+ConVar object_capture_damage( "obj_capture_damage", "0", 0, "Captures all damage taken by objects for dumping later." );
+
+CUtlDict<int,int> g_DamageMap;
+
+void Cmd_DamageDump_f(void)
+{	
+	CUtlDict<bool,int> g_UniqueColumns;
+
+	// Build the unique columns:
+	for( int idx = g_DamageMap.First(); idx != g_DamageMap.InvalidIndex(); idx = g_DamageMap.Next(idx) )
+	{
+		char* szColumnName = strchr(g_DamageMap.GetElementName(idx),',') + 1;
+
+		int ColumnIdx = g_UniqueColumns.Find( szColumnName );
+
+		if( ColumnIdx == g_UniqueColumns.InvalidIndex() ) 
+		{
+			g_UniqueColumns.Insert( szColumnName, false );
+		}
+	}
+
+	// Dump the column names:
+	FileHandle_t f = filesystem->Open("damage.txt","wt+");
+
+	for( idx = g_UniqueColumns.First(); idx != g_UniqueColumns.InvalidIndex(); idx = g_UniqueColumns.Next(idx) )
+	{
+		filesystem->FPrintf(f,"\t%s",g_UniqueColumns.GetElementName(idx));
+	}
+
+	filesystem->FPrintf(f,"\n");
+
+ 
+	CUtlDict<bool,int> g_CompletedRows;
+
+	// Dump each row:
+	bool bDidRow;
+
+	do
+	{
+		bDidRow = false;
+
+		for( idx = g_DamageMap.First(); idx != g_DamageMap.InvalidIndex(); idx = g_DamageMap.Next(idx) )
+		{
+			char szRowName[256];
+
+			// Check the Row name of each entry to see if I've done this row yet.
+			Q_strncpy(szRowName, g_DamageMap.GetElementName(idx), sizeof( szRowName ) );
+			*strchr(szRowName,',') = '\0';
+
+			char szRowNameComma[256];
+			Q_snprintf( szRowNameComma, sizeof( szRowNameComma ), "%s,", szRowName );
+
+			if( g_CompletedRows.Find(szRowName) == g_CompletedRows.InvalidIndex() )
+			{
+				bDidRow = true;
+				g_CompletedRows.Insert(szRowName,false);
+
+
+				// Output the row name:
+				filesystem->FPrintf(f,szRowName);
+
+				for( int ColumnIdx = g_UniqueColumns.First(); ColumnIdx != g_UniqueColumns.InvalidIndex(); ColumnIdx = g_UniqueColumns.Next( ColumnIdx ) )
+				{
+					char szRowNameCommaColumn[256];
+					Q_strncpy( szRowNameCommaColumn, szRowNameComma, sizeof( szRowNameCommaColumn ) );					
+					Q_strncat( szRowNameCommaColumn, g_UniqueColumns.GetElementName( ColumnIdx ), sizeof( szRowNameCommaColumn ), COPY_ALL_CHARACTERS );
+
+					int nDamageAmount = 0;
+					// Fine to reuse idx since we are going to break anyways.
+					for( idx = g_DamageMap.First(); idx != g_DamageMap.InvalidIndex(); idx = g_DamageMap.Next(idx) )
+					{
+						if( !stricmp( g_DamageMap.GetElementName(idx), szRowNameCommaColumn ) )
+						{
+							nDamageAmount = g_DamageMap[idx];
+							break;
+						}
+					}
+
+					filesystem->FPrintf(f,"\t%i",nDamageAmount);
+
+				}
+
+				filesystem->FPrintf(f,"\n");
+				break;
+			}
+		}
+		// Grab the row name:
+
+	} while(bDidRow);
+
+	// close the file:
+	filesystem->Close(f);
+}
+
+static ConCommand obj_dump_damage( "obj_dump_damage", Cmd_DamageDump_f );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ReportDamage( const char* szInflictor, const char* szVictim, float fAmount, int nCurrent, int nMax )
+{
+	int iAmount = (int)fAmount;
+
+	if( object_show_damage.GetBool() && iAmount )
+	{
+		Msg( "ShowDamage: Object %s taking %0.1f damage from %s ( %i / %i )\n", szVictim, fAmount, szInflictor, nCurrent, nMax );
+	}
+
+	if( object_capture_damage.GetBool() )
+	{
+		char szMangledKey[256];
+
+		Q_snprintf(szMangledKey,sizeof(szMangledKey)/sizeof(szMangledKey[0]),"%s,%s",szInflictor,szVictim);
+		int idx = g_DamageMap.Find( szMangledKey );
+
+		if( idx == g_DamageMap.InvalidIndex() )
+		{
+			g_DamageMap.Insert( szMangledKey, iAmount );
+
+		} else
+		{
+			g_DamageMap[idx] += iAmount;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Pass the specified amount of damage through to any objects I have built on me
+//-----------------------------------------------------------------------------
+bool CBaseObject::PassDamageOntoChildren( const CTakeDamageInfo &info, float *flDamageLeftOver )
+{
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(this);
+	Assert( pBPInterface );
+
+	float flDamage = info.GetDamage();
+
+	// Double the amount of damage done (and get around the child damage modifier)
+	flDamage *= 2;
+	if ( obj_child_damage_factor.GetFloat() )
+	{
+		flDamage *= (1 / obj_child_damage_factor.GetFloat());
+	}
+
+	// Remove blast damage because child objects (well specifically upgrades)
+	// want to ignore direct blast damage but still take damage from parent
+	CTakeDamageInfo childInfo = info;
+	childInfo.SetDamage( flDamage );
+	childInfo.SetDamageType( info.GetDamageType() & (~DMG_BLAST) );
+
+	CBaseEntity *pEntity = pBPInterface->GetFirstObjectOnMe();
+	while ( pEntity )
+	{
+		Assert( pEntity->m_takedamage != DAMAGE_NO );
+		// Do damage to the next object
+		float flDamageTaken = pEntity->OnTakeDamage( childInfo );
+		// If we didn't kill it, abort
+		CBaseObject *pObject = dynamic_cast<CBaseObject*>(pEntity);
+		if ( !pObject || !pObject->IsDying() )
+		{
+			char* szInflictor = "unknown";
+			if( info.GetInflictor() )
+				szInflictor = (char*)info.GetInflictor()->GetClassname();
+
+			ReportDamage( szInflictor, GetClassname(), flDamageTaken, GetHealth(), GetMaxHealth() );
+
+			*flDamageLeftOver = flDamage;
+			return true;
+		}
+		// Reduce the damage and move on to the next
+		flDamage -= flDamageTaken;
+		pEntity = pBPInterface->GetFirstObjectOnMe();
+	}
+
+	*flDamageLeftOver = flDamage;
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseObject::OnTakeDamage( const CTakeDamageInfo &info )
+{
+	// Prevent damage if the game hasn't started yet
+	if ( CurrentActIsAWaitingAct() )
+		return 0;
+	if ( !IsAlive() )
+		return info.GetDamage();
+	if (m_bInvulnerable)
+		return 0;
+	if ( m_takedamage == DAMAGE_NO )
+		return 0;
+	if ( IsPlacing() )
+		return 0;
+
+	// Check teams
+	if ( info.GetAttacker() )
+	{
+		if ( InSameTeam(info.GetAttacker()) )
+			return 0;
+	}
+
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(this);
+
+	float flDamage = info.GetDamage();
+
+	// Objects take half damage from bullets
+	if ( info.GetDamageType() & DMG_BULLET )
+	{
+		flDamage *= 0.5;
+	}
+
+	// Objects build on other objects take less damage
+	if ( !IsAnUpgrade() && GetParentObject() )
+	{
+		flDamage *= obj_child_damage_factor.GetFloat();
+	}
+
+	if (obj_damage_factor.GetFloat())
+	{
+		flDamage *= obj_damage_factor.GetFloat();
+	}
+
+	// Constructing objects take extra damage
+	if ( IsBuilding() )
+	{
+		flDamage *= 3;
+	}
+
+	// If has min health, and damage would put it below min health disable it if not already disabled
+	bool bShouldBeDisabled = false;
+	if ( m_flMinDisableHealth != 0 && ( m_flHealth - flDamage ) < m_flMinDisableHealth )
+	{
+		bShouldBeDisabled = true;
+	}
+	else if ( pBPInterface && pBPInterface->GetNumObjectsOnMe() && (( m_flHealth - flDamage ) < 1) )
+	{
+		bShouldBeDisabled = true;
+	}
+
+	// Make sure we're disabled if we're supposed to be
+	if ( bShouldBeDisabled )
+	{
+		// Remove any sappers on me
+		if ( m_bCantDie )
+		{
+			RemoveAllSappers( this );
+		}
+
+		// Make sure this only fires first time we cross the threshold and go disabled
+		if ( !IsDisabled() )
+		{
+			SetDisabled( true );
+			m_OnBecomingDisabled.FireOutput( info.GetAttacker(), this );
+
+			// Special case: If we have a min disabled health, and we're set to not die, immediately fall to 1 health
+			if ( m_bCantDie )
+			{
+				SetHealth( 1 );
+			}
+		}
+	}
+
+	// If I have objects on me, I can't be destroyed until they're gone. Ditto if I can't be killed.
+	bool bWillDieButCant = (m_bCantDie || pBPInterface->GetNumObjectsOnMe()) && (( m_flHealth - flDamage ) < 1);
+	if ( bWillDieButCant )
+	{
+		// Soak up the damage it would take to drop us to 1 health
+		flDamage = flDamage - m_flHealth;
+		SetHealth( 1 );
+
+		// Pass leftover damage 
+		if ( flDamage )
+		{
+			if ( PassDamageOntoChildren( info, &flDamage ) )
+				return flDamage;
+		}
+	}
+
+	if ( flDamage )
+	{
+		// Recheck our death possibility, because our objects may have all been blown off us by now
+		bWillDieButCant = (m_bCantDie || pBPInterface->GetNumObjectsOnMe()) && (( m_flHealth - flDamage ) < 1);
+		if ( !bWillDieButCant )
+		{
+			// Reduce health
+			SetHealth( m_flHealth - flDamage );
+		}
+	}
+
+	m_OnDamaged.FireOutput(info.GetAttacker(), this);
+
+	// Hurt by an enemy?
+	if ( info.GetAttacker() && info.GetAttacker()->entindex() > 0 )
+	{
+		m_flLastRealDamage = gpGlobals->curtime;
+	}
+
+	if ( GetHealth() <= 0 )
+	{
+		if ( info.GetAttacker() )
+		{
+			TFStats()->IncrementTeamStat( info.GetAttacker()->GetTeamNumber(), TF_TEAM_STAT_DESTROYED_OBJECT_COUNT, 1 );
+			TFStats()->IncrementPlayerStat( info.GetAttacker(), TF_PLAYER_STAT_DESTROYED_OBJECT_COUNT, 1 );
+		}
+
+		m_lifeState = LIFE_DEAD;
+		m_OnDestroyed.FireOutput( info.GetAttacker(), this);
+		Killed();
+	}
+	else
+	{
+		// Notify team about interesting stuff going on with this object
+		if ( !(m_fObjectFlags & OF_SUPPRESS_NOTIFY_UNDER_ATTACK) && ( m_iszUnderAttackSound != NULL_STRING ) )
+		{
+			CTFTeam *pTeam = GetTFTeam();
+			if ( pTeam )
+			{
+				Vector vecPosition = GetAbsOrigin();
+
+				// Tell everyone on the team that this object's underattack
+				CRecipientFilter myteam;
+				myteam.MakeReliable();
+				myteam.AddRecipientsByTeam( pTeam );
+				UserMessageBegin( myteam, "MinimapPulse" );
+					WRITE_VEC3COORD( vecPosition );
+				MessageEnd();
+
+				GetTFTeam()->PostMessage( TEAMMSG_CUSTOM_SOUND, NULL, (char*)STRING(m_iszUnderAttackSound) );
+			}
+		}
+	}
+
+	{
+		char* szInflictor = "unknown";
+		if( info.GetInflictor() )
+			szInflictor = (char*)info.GetInflictor()->GetClassname();
+
+		ReportDamage( szInflictor, GetClassname(), flDamage, GetHealth(), GetMaxHealth() );
+	}
+
+	return flDamage;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the time it will take to repair this object
+//-----------------------------------------------------------------------------
+float CBaseObject::GetRepairTime( void )
+{
+	// Can't be repaired while being constructed
+	if ( IsBuilding() )
+		return 0;
+
+	int iRepairHealth = GetMaxHealth() - GetHealth();
+	if ( iRepairHealth )
+	{
+		return ((float)iRepairHealth / OBJECT_REPAIR_RATE);
+	}
+
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Repair myself for the time period passed in. Return true if I'm fully repaired.
+//-----------------------------------------------------------------------------
+bool CBaseObject::UpdateRepair( float flRepairTime )
+{
+	return Repair( (flRepairTime * OBJECT_REPAIR_RATE) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Repair / Help-Construct this object the specified amount
+//-----------------------------------------------------------------------------
+bool CBaseObject::Repair( float flHealth )
+{
+	// Multiply it by the repair rate
+	flHealth *= m_flRepairMultiplier;
+	if ( !flHealth )
+		return false;
+
+	if ( IsBuilding() )
+	{
+		if ( HasPowerup(POWERUP_EMP) )
+			return false;
+
+		// Reduce the construction time by the correct amount for the health passed in
+		float flConstructionTime = flHealth / ((GetMaxHealth() - OBJECT_CONSTRUCTION_STARTINGHEALTH) / m_flTotalConstructionTime);
+		m_flConstructionTimeLeft = MAX( 0, m_flConstructionTimeLeft - flConstructionTime);
+		m_flConstructionTimeLeft = clamp( m_flConstructionTimeLeft, 0.0f, m_flTotalConstructionTime );
+		m_flPercentageConstructed = 1 - (m_flConstructionTimeLeft / m_flTotalConstructionTime);
+		m_flPercentageConstructed = clamp( m_flPercentageConstructed, 0.0f, 1.0f );
+
+		// Increase health.
+		SetHealth( MIN( GetMaxHealth(), m_flHealth + flHealth ) );
+
+		// Return true if we're constructed now
+		if ( m_flConstructionTimeLeft <= 0.0f )
+		{
+			FinishedBuilding();
+			return true;
+		}
+	}
+	else
+	{
+		// Return true if we're already fully healed
+		if ( GetHealth() >= GetMaxHealth() )
+			return true;
+
+		// Increase health.
+		SetHealth( MIN( GetMaxHealth(), m_flHealth + flHealth ) );
+
+		m_OnRepaired.FireOutput( this, this);
+
+		// Return true if we're fully healed now
+		if ( GetHealth() == GetMaxHealth() )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Object has been blown up. Drop resource chunks upto the value of my max health.
+//-----------------------------------------------------------------------------
+void CBaseObject::Killed( void )
+{
+	m_bDying = true;
+
+	// Do an explosion.
+	CPASFilter filter( GetAbsOrigin() );
+	te->Explosion( 
+		filter, 
+		0.0,				
+		&GetAbsOrigin(),
+		g_sModelIndexFireball,
+		5.4,		// radius
+		15,
+		TE_EXPLFLAG_NODLIGHTS,
+		256,
+		200);
+
+	Vector vecOrigin = WorldSpaceCenter() + Vector(0,0,32);
+
+	bool bDropResources = true;
+
+	// Don't drop resources if I'm built out of brushes, or I'm an upgrade
+	if ( m_fObjectFlags & OF_DOESNT_HAVE_A_MODEL || IsAnUpgrade() )
+	{
+		bDropResources = false;
+	}
+
+	// Don't drop resources if I haven't taken damage from an enemy for a while (i.e. I've deteriorated instead)
+	if ( gpGlobals->curtime > (m_flLastRealDamage + MAX_DROP_TIME_AFTER_DAMAGE) )
+	{
+		bDropResources = false;
+	}
+
+	// Drop resources based upon our base cost
+	int iCost = CalculateObjectCost( GetType(), 0, GetTeamNumber() );
+	iCost *= 0.5;
+	if ( bDropResources && iCost )
+	{
+		// Convert value to chunks.
+		int nProcessedChunks = 0;
+		int nNormalChunks = 0;
+		ConvertResourceValueToChunks( iCost, &nProcessedChunks, &nNormalChunks );
+
+		// Make everything drop at least 1 chunk
+		if ( !nProcessedChunks && !nNormalChunks )
+		{
+			nNormalChunks++;
+		}
+
+		// Drop processed chunks.
+		int iChunk;
+		for ( iChunk = 0; iChunk < nProcessedChunks; iChunk++ )
+		{
+			// Generate a random velocity vector.
+			Vector vecVelocity = Vector( random->RandomFloat( -250,250 ), random->RandomFloat( -250,250 ), random->RandomFloat( 200,450 ) );
+
+			// Create a processed chunk.
+			CResourceChunk *pChunk = CResourceChunk::Create( true, vecOrigin, vecVelocity );
+			pChunk->ChangeTeam( GetTeamNumber() );
+		}
+
+		// Drop normal chunks
+		for ( iChunk = 0; iChunk < nNormalChunks; iChunk++ )
+		{
+			// Generate a random velocity vector.
+			Vector vecVelocity = Vector( random->RandomFloat( -250,250 ), random->RandomFloat( -250,250 ), random->RandomFloat( 200,450 ) );
+
+			// Create a processed chunk.
+			CResourceChunk *pChunk = CResourceChunk::Create( false, vecOrigin, vecVelocity );
+			pChunk->ChangeTeam( GetTeamNumber() );
+		}
+
+		TFStats()->IncrementTeamStat( GetTeamNumber(), TF_TEAM_STAT_RESOURCE_CHUNKS_DROPPED, (resource_chunk_processed_value.GetFloat() * nProcessedChunks) + (resource_chunk_value.GetFloat() * nNormalChunks) );
+	}
+
+	DetachObjectFromObject();
+
+	UTIL_Remove( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Indicates this NPC's place in the relationship table.
+//-----------------------------------------------------------------------------
+Class_T	CBaseObject::Classify( void )
+{
+	return (CLASS_MILITARY);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the type of this object
+//-----------------------------------------------------------------------------
+int	CBaseObject::GetType()
+{
+	return m_iObjectType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the builder of this object
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CBaseObject::GetBuilder( void )
+{
+	return m_hBuilder;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the original builder of this object
+//			Used to get the builder of a deteriorating object
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CBaseObject::GetOriginalBuilder( void )
+{
+	return m_hOriginalBuilder;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the Owning CTeam should clean this object up automatically
+//-----------------------------------------------------------------------------
+bool CBaseObject::ShouldAutoRemove( void )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: If the object's still being built, it's not usable
+//-----------------------------------------------------------------------------
+int	CBaseObject::ObjectCaps( void ) 
+{ 
+	if ( IsPlacing() )
+		return 0;
+
+	// If I'm being built, only allow +use if I don't have a sapper on me and I haven't been disabled by a plasma weapon
+	if ( IsBuilding() && !HasSapper() && !IsPlasmaDisabled() )
+		return 0;
+
+	return FCAP_ONOFF_USE; 
+};
+
+//-----------------------------------------------------------------------------
+// Clean off the object of offensive material...
+//-----------------------------------------------------------------------------
+bool CBaseObject::RemoveEnemyAttachments( CBaseEntity *pActivator )
+{
+	bool bRemoved = false;
+
+	// Sapper removal
+	if ( pActivator->IsPlayer() )
+	{
+		if ( HasSapper() )
+		{
+			RemoveAllSappers( pActivator );
+			bRemoved = true;
+		}
+	}
+
+	return bRemoved;
+}
+
+
+//-----------------------------------------------------------------------------
+// Object using!
+//-----------------------------------------------------------------------------
+void CBaseObject::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	// If we're friendly, pickup / remove sappers
+	// If we're an enemy, plant a sapper
+	if ( pActivator->IsPlayer() )
+	{
+		if ( InSameTeam( pActivator ) )
+		{
+			if ( useType == USE_ON )
+			{
+				// Some combat objects can be picked up
+				if ( m_fObjectFlags & OF_CAN_BE_PICKED_UP )
+				{
+					if ( GetBuilder() == pActivator )
+					{
+						if ( GetBuilder()->GetPlayerClass()->ResupplyAmmoType( 1, m_szAmmoName ) )
+						{
+							PickupObject();
+						}
+						return;
+					}
+				}
+
+				// Sapper removal
+				if ( RemoveEnemyAttachments( pActivator ) )
+					return;
+			}
+		}
+		else
+		{
+			CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pActivator;
+
+			// If we're already planting a sapper, abort
+			if ( useType == USE_OFF || pPlayer->IsAttachingSapper() ) 
+			{
+				// Don't abort if we just started placing it. This is to catch people who'd like to +use toggle instead of hold down
+				if ( pPlayer->GetSapperAttachmentTime() > 0.2 && pPlayer->IsAttachingSapper() )
+				{
+					pPlayer->StopAttaching();
+				}
+			}
+			else if ( useType == USE_ON )
+			{
+				// Don't allow sappers to be planted on invulnerable objects
+				if ( m_bInvulnerable )
+					return;
+
+				// If the object's already got a sapper from me on it, I can't put another
+				if ( HasSapperFromPlayer( ((CBaseTFPlayer*)pActivator ) ) )
+					return;
+
+				Vector vecAiming;
+				pPlayer->EyeVectors( &vecAiming );
+				// Trace from the player to the object to find an attachment position
+				trace_t tr;
+				Vector vecStart = pPlayer->EyePosition();
+				UTIL_TraceLine( vecStart, vecStart + (vecAiming * 256), MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+				if ( tr.fraction < 1.0 && tr.m_pEnt == this )
+				{
+					CGrenadeObjectSapper *sapper = CGrenadeObjectSapper::Create( tr.endpos, vecAiming, pPlayer, this );
+					pPlayer->StartAttachingSapper( this, sapper );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builder has picked up the object
+//-----------------------------------------------------------------------------
+void CBaseObject::PickupObject( void )
+{
+	// Tell the playerclass
+	if ( GetBuilder() && GetBuilder()->GetPlayerClass() )
+	{
+		GetBuilder()->GetPlayerClass()->PickupObject( this );
+	}
+
+	UTIL_Remove( this );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified player's allowed to remove this object
+//-----------------------------------------------------------------------------
+bool CBaseObject::CanBeRemovedBy( CBaseTFPlayer *pPlayer )
+{
+	if ( m_fObjectFlags & OF_CANNOT_BE_DISMANTLED )
+		return false;
+
+	// If I'm a map-defined object, I'm not removable by anyone
+	if ( WasMapPlaced() )
+		return false;
+
+	// If I have an owner, only he can remove me
+	if ( GetBuilder() != pPlayer )
+		return false;
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified player's allowed to rotate this object
+//-----------------------------------------------------------------------------
+bool CBaseObject::CanBeRotatedBy( CBaseTFPlayer *pPlayer )
+{
+	// If I'm a map-defined object, I'm not removable by anyone
+	if ( WasMapPlaced() )
+		return false;
+
+	// If I have an owner, only he can remove me
+	if ( GetBuilder() != pPlayer )
+		return false;
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iTeamNum - 
+//-----------------------------------------------------------------------------
+void CBaseObject::ChangeTeam( int iTeamNum )
+{
+	CTFTeam *pTeam = ( CTFTeam * )GetGlobalTeam( iTeamNum );
+	CTFTeam *pExisting = ( CTFTeam * )GetTeam();
+
+	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseObject::ChangeTeam old %s new %s\n", gpGlobals->curtime, 
+		pExisting ? pExisting->GetName() : "NULL",
+		pTeam ? pTeam->GetName() : "NULL" ) );
+
+	// Already on this team
+	if ( GetTeamNumber() == iTeamNum )
+		return;
+
+	if ( pExisting )
+	{
+		// Remove it from current team ( if it's in one ) and give it to new team
+		pExisting->RemoveObject( this );
+	}
+		
+	// Change to new team
+	BaseClass::ChangeTeam( iTeamNum );
+	
+	// Add this object to the team's list
+	// But only if we're not placing it
+	if ( pTeam && (!m_bPlacing) )
+	{
+		pTeam->AddObject( this );
+	}
+
+	// Setup for our new team's model
+	SetupTeamModel();
+	CreateBuildPoints();
+	CreateVulnerablePoints();
+
+	// Alien buildings never need power
+	if ( GetTeamNumber() == TEAM_ALIENS )
+	{
+		m_fObjectFlags |= OF_DOESNT_NEED_POWER;
+	}
+
+	GainedNewTechnology( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CBaseObject::GetWeaponClassnameForObject( void )
+{
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pNewOwner - 
+//-----------------------------------------------------------------------------
+void CBaseObject::AddItemsNeededForObject( CBaseTFPlayer *pNewOwner )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Derived classes might want to give the new builder the appropriate
+//  items needed to own this object and move the objects owned over as well
+// Input  : *pNewOwner - 
+//-----------------------------------------------------------------------------
+void CBaseObject::ChangeBuilder( CBaseTFPlayer *pNewBuilder, bool moveobjects )
+{
+	CBaseTFPlayer *oldBuilder = GetOwner();
+
+	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseObject::ChangeBuilder old %s, new %s, moveobjects %s\n", gpGlobals->curtime, 
+		oldBuilder ? oldBuilder->GetPlayerName() : "NULL",
+		pNewBuilder ? pNewBuilder->GetPlayerName() : "NULL",
+		moveobjects ? "true" : "false" ) );
+
+	// Store off original builder
+	if ( GetOwner() )
+	{
+		m_hOriginalBuilder = GetOwner();
+	}
+
+	m_hBuilder = pNewBuilder;
+
+	if ( !moveobjects )
+		return;
+
+	if ( oldBuilder )
+	{
+		oldBuilder->OwnedObjectChangeTeam( this, pNewBuilder );
+	}
+
+	// For instance, if this is a mortar being added to a technician via subversion, then
+	//  the "weapon_mortar" will be added to the player if the player doesn't have it.
+	AddItemsNeededForObject( pNewBuilder );
+
+	const char *classname = GetWeaponClassnameForObject();
+	if ( !classname )
+		return;
+
+	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseObject::ChangeBuilder moving associated objects %s\n", gpGlobals->curtime, 
+		classname ) );
+
+	// Find the old player who owned a weapon that owned this object type and remove it 
+	// Then add to current player under the approrpriate weapon ( same classname ) which
+	//  should have been added in ChangeBuilder
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CBaseTFPlayer *player = static_cast< CBaseTFPlayer *>( UTIL_PlayerByIndex( i ) );
+		if ( !player )
+			continue;
+
+		// Cycle through weapons
+		for ( int j = 0; j < player->WeaponCount(); j++ )
+		{
+			if ( !player->GetWeapon( j ) )
+				continue;
+
+			if ( !FClassnameIs( player->GetWeapon( j ), classname ) )
+				continue;
+
+			// Add to this player
+			if ( player == pNewBuilder )
+			{
+				( ( CBaseTFCombatWeapon * )player->GetWeapon( j ))->AddAssociatedObject( this );
+			}
+			// Remove from any other
+			else
+			{
+				( ( CBaseTFCombatWeapon * )player->GetWeapon( j ))->RemoveAssociatedObject( this );
+			}
+		}
+
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if I have at least 1 sapper on me
+//-----------------------------------------------------------------------------
+bool CBaseObject::HasSapper( void )
+{
+	return ( m_hSappers.Size() > 0 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified player has attached a sapper to me
+//-----------------------------------------------------------------------------
+bool CBaseObject::HasSapperFromPlayer( CBaseTFPlayer *pPlayer )
+{
+	for ( int i = 0; i < m_hSappers.Size(); i++ )
+	{
+		if ( m_hSappers[i] == NULL )
+			continue;
+
+		if ( m_hSappers[i]->GetThrower() == pPlayer )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a sapper to this object
+//-----------------------------------------------------------------------------
+void CBaseObject::AddSapper( CGrenadeObjectSapper *pSapper )
+{
+	SapperHandle hSapper;
+	hSapper = pSapper;
+	m_hSappers.AddToTail( hSapper );
+	m_bHasSapper = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tell all sappers on this object to remove themselves 
+//-----------------------------------------------------------------------------
+void CBaseObject::RemoveAllSappers( CBaseEntity *pRemovingEntity )
+{
+	// Loop through all the sappers and fire a +use on them (backwards because list will change)
+	int iSize = m_hSappers.Size();
+	for (int i = iSize-1; i >= 0; i--)
+	{
+		m_hSappers[i]->Use( pRemovingEntity, pRemovingEntity, USE_TOGGLE, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove a sapper from this object
+//-----------------------------------------------------------------------------
+void CBaseObject::RemoveSapper( CGrenadeObjectSapper *pSapper )
+{
+	SapperHandle hSapper;
+	hSapper = pSapper;
+	m_hSappers.FindAndRemove( hSapper );
+	m_bHasSapper = HasSapper();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: My owner's just received a new technology, see if it affects me
+//-----------------------------------------------------------------------------
+void CBaseObject::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+	// Base object doesn't respond to tech
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pRecipient - 
+//			*techname - 
+//-----------------------------------------------------------------------------
+void CBaseObject::GiveNamedTechnology( CBaseTFPlayer *pRecipient, const char *techname )
+{
+	CTFTeam *team = static_cast< CTFTeam * >( pRecipient->GetTeam() );
+	if ( !team )
+		return;
+
+	CBaseTechnology *tech = team->m_pTechnologyTree->GetTechnology( techname );
+	if ( tech )
+	{
+		team->EnableTechnology( tech, true );
+	}
+}
+
+
+bool CBaseObject::ShowVGUIScreen( int panelIndex, bool bShow )
+{
+	Assert( panelIndex >= 0 && panelIndex < m_hScreens.Count() );
+	if ( m_hScreens[panelIndex].Get() )
+	{
+		m_hScreens[panelIndex]->SetActive( bShow );
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if this object was placed in the map, not built by a player
+//-----------------------------------------------------------------------------
+bool CBaseObject::WasMapPlaced( void )
+{
+	return m_bWasMapPlaced;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find nearby objects on my team and connect to them
+//-----------------------------------------------------------------------------
+CRopeKeyframe *CBaseObject::ConnectCableTo( CBaseObject *pObject, int iLocalAttachment, int iTargetAttachment )
+{
+	// Connect to it
+	CRopeKeyframe *pRope = CRopeKeyframe::Create( this, pObject, iLocalAttachment, iTargetAttachment );
+	if ( pRope )
+	{
+		pRope->m_Width = 3;
+		pRope->m_nSegments = ROPE_MAX_SEGMENTS;
+		//pRope->m_RopeFlags |= (ROPE_RESIZE | ROPE_COLLIDE);
+		pRope->EnableCollision();
+		pRope->EnableWind( false );
+		pRope->SetupHangDistance( ROPE_HANG_DIST );
+		pRope->ActivateStartDirectionConstraints( true );
+		pRope->ActivateEndDirectionConstraints( true );
+	}
+
+	// Add the rope to both Object's lists
+	CHandle< CRopeKeyframe > hHandle;
+	hHandle = pRope;
+	m_aRopes.AddToTail( hHandle );
+	pObject->m_aRopes.AddToTail( hHandle );
+
+	// During placement, the rules for whether the rope is transmitted or not are 
+	// tricky, so we make a proxy here to control it.
+	if ( IsPlacing() || pObject->IsPlacing() )
+	{
+		CObjectRopeTransmitProxy *pProxy = new CObjectRopeTransmitProxy( pRope );
+		pProxy->m_hObj1 = this;
+		pProxy->m_hObj2 = pObject;
+		// pRope->NetworkProp()->SetTransmitProxy( pProxy ); TODO
+	}
+
+	return pRope;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if I have a cable to the specified object
+//-----------------------------------------------------------------------------
+bool CBaseObject::HasCableTo( CBaseObject *pObject )
+{
+	for (int i = 0; i < m_aRopes.Size(); i++)
+	{
+		CHandle< CRopeKeyframe > hHandle;
+		hHandle = m_aRopes[i];
+		if ( hHandle )
+		{
+			if ( m_aRopes[i]->GetEndPoint() == pObject )
+				return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return an attachment point for a cable
+//-----------------------------------------------------------------------------
+int CBaseObject::GetCableAttachment( void )
+{
+	Vector vecOrigin, vecAngles;
+	// If I already have a rope attached, try and use a different attachment point
+	if ( m_aRopes.Size() )
+	{
+		// First, check to see if we've lost any ropes (this can happen because 
+		// the other object it was attached to has been destroyed.
+		int iSize = m_aRopes.Size();
+		for (int i = iSize-1; i >= 0; i--)
+		{
+			CHandle< CRopeKeyframe > hHandle;
+			hHandle = m_aRopes[i];
+			if ( hHandle == NULL )
+			{
+				m_aRopes.Remove(i);
+			}
+		}
+
+		// If I have enough connections, tell 'em I don't want no more
+		if ( m_aRopes.Size() >= MAX_CABLE_CONNECTIONS )
+			return -1;
+
+		char sAttachment[32];
+		Q_snprintf( sAttachment,sizeof(sAttachment), "cablepoint%d", m_aRopes.Size() + 1 );
+		int iPoint = LookupAttachment( sAttachment );
+		if ( iPoint > 0 )
+			return iPoint;											
+	}
+
+
+	return LookupAttachment( "cablepoint1" );
+}
+
+
+//====================================================================================================================
+// POWER PACKS
+//====================================================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetPowerPack( CObjectPowerPack *pPack )
+{
+	bool bHadPower = HasPowerup( POWERUP_POWER );
+	CObjectPowerPack *pOldPack = m_hPowerPack;
+
+	m_hPowerPack = pPack;
+
+	// If it's placing, I don't get power yet
+	if ( m_hPowerPack && !m_hPowerPack->IsPlacing() )
+	{
+		SetPowerup( POWERUP_POWER, true );
+	}
+	else
+	{
+		// Lose power in a second, to give any nearby powerpacks time to connect to me and replace the power
+		if ( bHadPower )
+		{
+			SetContextThink( LostPowerThink, gpGlobals->curtime + 1.0, OBJ_LOSTPOWER_THINK_CONTEXT );
+			if ( GetTFTeam() )
+			{
+				// Dirty hack to make powerpack think I need power
+				m_iPowerups &= ~(1 << POWERUP_POWER);
+				GetTFTeam()->UpdatePowerpacks( pOldPack, this );
+			}
+		}
+		else
+		{
+			SetPowerup( POWERUP_POWER, false );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've lost power fully
+//-----------------------------------------------------------------------------
+void CBaseObject::LostPowerThink( void )
+{
+	// We may have found another powerpack
+	if ( !m_hPowerPack )
+	{
+		// Dirty hack to get our powerup removed properly
+		m_iPowerups |= (1 << POWERUP_POWER);
+		SetPowerup( POWERUP_POWER, false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the health of the object
+//-----------------------------------------------------------------------------
+void CBaseObject::InputSetHealth( inputdata_t &inputdata )
+{
+	m_iMaxHealth = inputdata.value.Int();
+	SetHealth( m_iMaxHealth );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add health to the object
+//-----------------------------------------------------------------------------
+void CBaseObject::InputAddHealth( inputdata_t &inputdata )
+{
+	int iHealth = inputdata.value.Int();
+	SetHealth( MIN( GetMaxHealth(), m_flHealth + iHealth ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove health from the object
+//-----------------------------------------------------------------------------
+void CBaseObject::InputRemoveHealth( inputdata_t &inputdata )
+{
+	int iDamage = inputdata.value.Int();
+
+	SetHealth( m_flHealth - iDamage );
+	if ( GetHealth() <= 0 )
+	{
+		m_lifeState = LIFE_DEAD;
+		m_OnDestroyed.FireOutput(this, this);
+		Killed();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CBaseObject::InputSetMinDisabledHealth( inputdata_t &inputdata )
+{
+	float minhealth = inputdata.value.Float();
+
+	bool wasdisabled = IsDisabled();
+
+	if ( m_flHealth < minhealth )
+	{
+		SetDisabled( true );
+		// NOTE:  This could theoretically add health, sigh.
+		SetHealth( minhealth );
+
+		// Disable it if not already disabled
+		if ( !wasdisabled )
+		{
+			m_OnBecomingDisabled.FireOutput( inputdata.pActivator, this );
+		}
+	}
+	else if ( wasdisabled && ( m_flHealth > minhealth ) )
+	{
+		SetDisabled( false );
+
+		m_OnBecomingReenabled.FireOutput( inputdata.pActivator, this );
+	}
+
+	m_flMinDisableHealth = minhealth;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CBaseObject::InputSetSolidToPlayer( inputdata_t &inputdata )
+{
+	int ival = inputdata.value.Int();
+	ival = clamp( ival, (int)SOLID_TO_PLAYER_USE_DEFAULT, (int)SOLID_TO_PLAYER_NO );
+	OBJSOLIDTYPE stp = (OBJSOLIDTYPE)ival;
+	SetSolidToPlayers( stp );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::PlayStartupAnimation( void )
+{
+	SetActivity( ACT_OBJ_STARTUP );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::DetermineAnimation( void )
+{
+	Activity desiredActivity = m_Activity;
+
+	switch ( m_Activity )
+	{
+	default:
+		{
+			if ( IsPlacing() )
+			{
+				desiredActivity = ACT_OBJ_PLACING;
+			}
+			else if ( IsBuilding() )
+			{
+				desiredActivity = ACT_OBJ_ASSEMBLING;
+			}
+			/*
+			TODO:
+				ACT_OBJ_DISMANTLING;
+				ACT_OBJ_DETERIORATING;
+			*/
+			else
+			{
+				desiredActivity = ACT_OBJ_RUNNING;
+			}
+		}
+		break;
+	case ACT_OBJ_STARTUP:
+		{
+			if ( IsActivityFinished() )
+			{
+				desiredActivity = ACT_OBJ_RUNNING;
+			}
+		}
+		break;
+	}
+
+	if ( desiredActivity == m_Activity )
+		return;
+
+	SetActivity( desiredActivity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attach this object to the specified object
+//-----------------------------------------------------------------------------
+
+void CBaseObject::AttachObjectToObject( const CBaseEntity *pEntity, int iPoint, Vector &vecOrigin )
+{
+	SetupAttachedVersion();
+
+	m_hBuiltOnEntity = pEntity;
+	m_iBuiltOnPoint = iPoint;
+
+	if ( m_hBuiltOnEntity.Get() )
+	{
+		// Parent ourselves to the object
+		int iAttachment = 0;
+		const IHasBuildPoints *pBPInterface = dynamic_cast<const IHasBuildPoints*>( pEntity );
+		if ( pBPInterface )
+			iAttachment = pBPInterface->GetBuildPointAttachmentIndex( iPoint );
+
+		SetParent( m_hBuiltOnEntity.Get(), iAttachment );
+
+		if ( iAttachment >= 1 )
+		{
+			// Stick right onto the attachment point.
+			vecOrigin.Init();
+			SetLocalOrigin( vecOrigin );
+			SetLocalAngles( QAngle(0,0,0) );
+		}
+		else
+		{
+			SetAbsOrigin( vecOrigin );
+			vecOrigin = GetLocalOrigin();
+		}
+	}
+
+	Assert( m_hBuiltOnEntity == GetMoveParent() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Detach this object from its parent, if it has one
+//-----------------------------------------------------------------------------
+void CBaseObject::DetachObjectFromObject( void )
+{
+	if ( !GetParentObject() )
+		return;
+
+	// Clear the build point
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(GetParentObject() );
+	Assert( pBPInterface );
+	pBPInterface->SetObjectOnBuildPoint( m_iBuiltOnPoint, NULL );
+
+	SetParent( NULL );
+	m_hBuiltOnEntity = NULL;
+	m_iBuiltOnPoint = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn any objects specified inside the mdl
+//-----------------------------------------------------------------------------
+void CBaseObject::SpawnEntityOnBuildPoint( const char *pEntityName, int iAttachmentNumber )
+{
+	// Try and spawn the object
+	CBaseEntity *pEntity = CreateEntityByName( pEntityName );
+	if ( !pEntity )
+		return;
+
+	Vector vecOrigin;
+	QAngle vecAngles;
+	GetAttachment( iAttachmentNumber, vecOrigin, vecAngles );
+	pEntity->SetAbsOrigin( vecOrigin );
+	pEntity->SetAbsAngles( vecAngles );
+	pEntity->Spawn();
+	
+	// If it's an object, finish setting it up
+	CBaseObject *pObject = dynamic_cast<CBaseObject*>(pEntity);
+	if ( !pObject )
+		return;
+
+	// Add a buildpoint here
+	int iPoint = AddBuildPoint( iAttachmentNumber );
+	AddValidObjectToBuildPoint( iPoint, pObject->GetType() );
+	pObject->SetBuilder( GetBuilder() );
+	pObject->ChangeTeam( GetTeamNumber() );
+	pObject->SpawnControlPanels();
+	pObject->SetHealth( pObject->GetMaxHealth() );
+	pObject->FinishedBuilding();
+	pObject->AttachObjectToObject( this, iPoint, vecOrigin );
+	pObject->m_fObjectFlags |= OF_CANNOT_BE_DISMANTLED;
+	pObject->AttemptToFindPower();
+
+	IHasBuildPoints *pBPInterface = dynamic_cast<IHasBuildPoints*>(this);
+	Assert( pBPInterface );
+	pBPInterface->SetObjectOnBuildPoint( iPoint, pObject );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn any objects specified inside the mdl
+//-----------------------------------------------------------------------------
+void CBaseObject::SpawnObjectPoints( void )
+{
+	KeyValues *modelKeyValues = new KeyValues("");
+	if ( !modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), modelinfo->GetModelKeyValueText( GetModel() ) ) )
+	{
+		modelKeyValues->deleteThis();
+		return;
+	}
+
+	// Do we have a build point section?
+	KeyValues *pkvAllObjectPoints = modelKeyValues->FindKey("object_points");
+	if ( !pkvAllObjectPoints )
+	{
+		modelKeyValues->deleteThis();
+		return;
+	}
+
+	// Start grabbing the sounds and slotting them in
+	KeyValues *pkvObjectPoint;
+	for ( pkvObjectPoint = pkvAllObjectPoints->GetFirstSubKey(); pkvObjectPoint; pkvObjectPoint = pkvObjectPoint->GetNextKey() )
+	{
+		// Find the attachment first
+		const char *sAttachment = pkvObjectPoint->GetName();
+		int iAttachmentNumber = LookupAttachment( sAttachment );
+		if ( iAttachmentNumber == 0 )
+		{
+			Msg( "ERROR: Model %s specifies object point %s, but has no attachment named %s.\n", STRING(GetModelName()), pkvObjectPoint->GetString(), pkvObjectPoint->GetString() );
+			continue;
+		}
+
+		// Now see what we're supposed to spawn there
+		// The count check is because it seems wrong to emit multiple entities on the same point
+		int nCount = 0;
+		KeyValues *pkvObject;
+		for ( pkvObject = pkvObjectPoint->GetFirstSubKey(); pkvObject; pkvObject = pkvObject->GetNextKey() )
+		{
+			SpawnEntityOnBuildPoint( pkvObject->GetName(), iAttachmentNumber );
+			++nCount;
+			Assert( nCount <= 1 );
+		}
+	}
+
+	modelKeyValues->deleteThis();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::CreateVulnerablePoints()
+{
+	KeyValues *modelKeyValues = new KeyValues("");
+	if ( !modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), modelinfo->GetModelKeyValueText( GetModel() ) ) )
+		return;
+
+	// Do we have a build point section?
+	KeyValues *pkvAllVulnerablePoints = modelKeyValues->FindKey("vulnerable_points");
+	if ( !pkvAllVulnerablePoints )
+		return;
+
+	// Start grabbing the sounds and slotting them in
+	KeyValues *pkvVulnerablePoint = pkvAllVulnerablePoints->GetFirstSubKey();
+	while ( pkvVulnerablePoint )
+	{
+		AddVulnerablePoint( pkvVulnerablePoint->GetName(), pkvVulnerablePoint->GetFloat() );
+		pkvVulnerablePoint = pkvVulnerablePoint->GetNextKey();
+	}
+
+}
+
+ConVar obj_debug_vulnerable( "obj_debug_vulnerable","0", FCVAR_NONE, "Show vulnerable points" );
+
+void CBaseObject::AddVulnerablePoint( const char* szName, float fMultiplier )
+{
+	// Make a new vulnerable point
+	VulnerablePoint_t v;
+	Q_memset(&v,0,sizeof(v));
+	v.m_fDamageMultiplier = fMultiplier;
+
+	int nSet, nBox;
+
+	if( !LookupHitbox(szName, nSet, nBox) )
+	{
+		Msg( "Error: Vulnerable point on model %s unable to locate hitbox %s\n", STRING(GetModelName()), szName);
+		return;
+	}
+
+	v.m_nSet = nSet;
+	v.m_nBox = nBox;
+
+	// Insert it into our list
+	if( obj_debug_vulnerable.GetBool() )
+	{
+		Msg( "Vulnerable point %s on model %s added with a damage multiplier of %f. (%i, %i)\n", szName, STRING(GetModelName()), fMultiplier, nSet, nBox);
+	}
+
+	m_VulnerablePoints.AddToTail( v );
+}
+
+
+float CBaseObject::FindVulnerablePointMultiplier( int nGroup, int nBox ) 		
+{
+	for( int i=0; i < m_VulnerablePoints.Count(); i++ )
+	{
+		VulnerablePoint_t& v = m_VulnerablePoints[i];
+
+		if( v.m_nBox == nBox /* && v.m_nSet == nGroup */)
+		{
+			if( obj_debug_vulnerable.GetBool() )
+			{
+				Msg("VulnerablePoint: %f\n",v.m_fDamageMultiplier);
+			}
+			return v.m_fDamageMultiplier;
+		}
+	}
+
+	if( obj_debug_vulnerable.GetBool() )
+	{
+		Msg("Couldn't find vulnerable point: %i %i\n",nGroup,nBox);
+	}
+	return 1.f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+QAngle CBaseObject::ConvertAbsAnglesToLocal( QAngle vecLocalAngles )
+{
+	if ( !GetMoveParent() )
+		return vecLocalAngles;
+
+	EntityMatrix vehicleToWorld, childMatrix;
+	vehicleToWorld.InitFromEntity( GetMoveParent() ); // parent->world
+
+	// Calculate the build point angles in vehicle space
+	VMatrix attachmentToWorld;
+	MatrixFromAngles( vecLocalAngles, attachmentToWorld );
+	
+	VMatrix worldToVehicle = vehicleToWorld.Transpose();
+	VMatrix attachmentToVehicle;
+	MatrixMultiply( worldToVehicle, attachmentToWorld, attachmentToVehicle );
+	QAngle vecAbsAngles;
+	MatrixToAngles( attachmentToVehicle, vecAbsAngles );
+
+	return vecAbsAngles;
+}
+
+bool CBaseObject::IsSolidToPlayers( void ) const
+{
+	switch ( m_SolidToPlayers )
+	{
+	default:
+		break;
+	case SOLID_TO_PLAYER_USE_DEFAULT:
+		{
+			if ( GetObjectInfo( ObjectType() ) )
+			{
+				return GetObjectInfo( ObjectType() )->m_bSolidToPlayerMovement;
+			}
+		}
+		break;
+	case SOLID_TO_PLAYER_YES:
+		return true;
+	case SOLID_TO_PLAYER_NO:
+		return false;
+	}
+
+	return false;
+}
+
+void CBaseObject::SetSolidToPlayers( OBJSOLIDTYPE stp, bool force )
+{
+	bool changed = stp != m_SolidToPlayers;
+	m_SolidToPlayers = stp;
+
+	if ( changed || force )
+	{
+		SetCollisionGroup( 
+			IsSolidToPlayers() ? 
+				TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT : 
+				TFCOLLISION_GROUP_OBJECT );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Hooks to support swapping out model if the object is damaged
+// Input  : bDisabled - 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetDisabled( bool bDisabled )
+{ 
+	bool changed = m_bDisabled != bDisabled;
+	m_bDisabled = bDisabled;
+
+	// value changed and mapper specified a "disabled"/damaged model
+	if ( changed && NULL_STRING != m_iszDisabledModel )
+	{
+		// Change model
+		SetModel( STRING( m_bDisabled ? m_iszDisabledModel : m_iszEnabledModel ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBaseObject::SetBuffStation( CObjectBuffStation *pBuffStation, bool bPlacing )	
+{ 
+	// Activate
+	if ( pBuffStation && !GetBuffStation() && !bPlacing && !IsBuilding() && IsPowered() )
+	{
+		BuffStationActivate();
+	}
+
+	if ( GetBuffStation() && ( pBuffStation == GetBuffStation() ) && !m_bBuffActivated && !bPlacing && !IsBuilding() && IsPowered() )
+	{
+		BuffStationActivate();
+	}
+
+	// Deactivate
+	if ( !pBuffStation && GetBuffStation() )
+	{
+		BuffStationDeactivate();
+	}
+
+	m_hBuffStation = pBuffStation; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CBaseObject::IsHookedAndBuffed( void )												
+{ 
+	if ( GetBuffStation() && HasPowerup( POWERUP_BOOST ) )
+	{
+		if ( GetBuffStation()->IsPowered() && !GetBuffStation()->IsPlacing() &&
+			 !GetBuffStation()->IsBuilding() )
+			return true;
+	}
+
+	return false;
+}