tf2/tf2_src/game/shared/tf/tf_robot_destruction_robot.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The robots for use in the Robot Destruction TF2 game mode.
//
//=========================================================================//

#include "cbase.h"
#include "tf_logic_robot_destruction.h"
#include "tf_shareddefs.h"
#include "particle_parse.h"
#include "tf_gamerules.h"
#include "debugoverlay_shared.h"
#ifdef  GAME_DLL
	#include "tf_ammo_pack.h"
	#include "entity_bonuspack.h"
	#include "entity_capture_flag.h"
	#include "effect_dispatch_data.h"
	#include "te_effect_dispatch.h"
	#include "tf_gamestats.h"
	#include "eventlist.h"
#else
	#include "eventlist.h"
#endif

#ifdef GAME_DLL
	extern ConVar tf_obj_gib_velocity_min;
	extern ConVar tf_obj_gib_velocity_max;
	extern ConVar tf_obj_gib_maxspeed;
#endif

#define ADD_POINTS_CONTEXT "add_points_context"
#define SPEW_BARS_CONTEXT "spew_bars_context"
#define SELF_DESTRUCT_THINK "self_destruct_think"
#define ANIMS_THINK	"anims_think"

ConVar tf_rd_robot_repair_rate( "tf_rd_robot_repair_rate", "60", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );

RobotData_t* g_RobotData[ NUM_ROBOT_TYPES ] =
{ 
					// Model									// Busted model										// Pain			// Death		// Collide		// Idle				// Bar offset
	new RobotData_t( "models/bots/bot_worker/bot_worker_A.mdl",	"models/bots/bot_worker/bot_worker_A.mdl",			"Robot.Pain",	"Robot.Death",	"Robot.Collide", "Robot.Greeting", -35.f ),
#ifdef STAGING_ONLY
	new RobotData_t( "models/bots/bot_worker/bot_worker_b.mdl",	"models/bots/bot_worker/bot_worker_b.mdl",			"Robot.Pain",	"Robot.Death",	"Robot.Collide", "Robot.Greeting", -30.f ),
#else
	new RobotData_t( "models/bots/bot_worker/bot_worker2.mdl", "models/bots/bot_worker/bot_worker2.mdl",			"Robot.Pain",	"Robot.Death",	"Robot.Collide", "Robot.Greeting", -30.f ),
#endif
	new RobotData_t( "models/bots/bot_worker/bot_worker3.mdl",	"models/bots/bot_worker/bot_worker3_nohead.mdl",	"Robot.Pain",	"Robot.Death",	"Robot.Collide", "Robot.Greeting", -10.f ),
};

#define ROBOT_DEATH_EXPLOSION "RD.BotDeathExplosion"
#define SCORING_POINTS_PARTICLE_EFFECT "bot_radio_waves"
#define DAMAGED_ROBOT_PARTICLE_EFFECT "sentrydamage_4"
#define DEATH_PARTICLE_EFFECT "rd_robot_explosion"


void RobotData_t::Precache()
{
	if ( GetStringData( MODEL_KEY ) )
	{
		CBaseEntity::PrecacheModel( GetStringData( MODEL_KEY ) );
		PrecacheGibsForModel( modelinfo->GetModelIndex( GetStringData( MODEL_KEY ) ) ); 
		PrecachePropsForModel( modelinfo->GetModelIndex( GetStringData( MODEL_KEY ) ), "spawn" );
	}
	if ( GetStringData( DAMAGED_MODEL_KEY ) ) CBaseEntity::PrecacheModel( GetStringData( DAMAGED_MODEL_KEY ) );
	if ( GetStringData( HURT_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( HURT_SOUND_KEY ) );
	if ( GetStringData( DEATH_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( DEATH_SOUND_KEY ) );
	if ( GetStringData( COLLIDE_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( COLLIDE_SOUND_KEY ) );
	if ( GetStringData( IDLE_SOUND_KEY ) ) CBaseEntity::PrecacheScriptSound( GetStringData( IDLE_SOUND_KEY ) );
}


CTFRobotDestruction_RobotAnimController::CTFRobotDestruction_RobotAnimController( CTFRobotDestruction_Robot *pOuter )
	: m_vecOldOrigin( vec3_origin )
	, m_vecLean( vec3_origin )
	, m_pOuter( pOuter )
	, m_vecImpulse( vec3_origin )
{}

void CTFRobotDestruction_RobotAnimController::Update()
{
	if( !m_pOuter )
		return;

	CStudioHdr *pStudioHdr = m_pOuter->GetModelPtr();
	if ( !pStudioHdr )
		return;

	const Vector vecNewOrigin = m_pOuter->GetAbsOrigin();
	const Vector vecVelocity = m_vecOldOrigin - vecNewOrigin;
	m_vecOldOrigin = vecNewOrigin;

	Approach( m_vecLean, vecVelocity + m_vecImpulse, 2.f );
	GetPoseParams();
	Approach( m_vecImpulse, vec3_origin, 200.f );

	Vector vecForward, vecRight;
	AngleVectors( m_pOuter->GetAbsAngles(), &vecForward, &vecRight, NULL );

	float flRightLean = vecRight.Dot( m_vecLean );
	float flForwardLean = vecForward.Dot( m_vecLean );

	m_pOuter->SetPoseParameter( m_poseParams.m_nMoveX, flForwardLean );
	m_pOuter->SetPoseParameter( m_poseParams.m_nMoveY, flRightLean );
}

void CTFRobotDestruction_RobotAnimController::Impulse( const Vector& vecImpulse )
{ 
	m_vecImpulse += vecImpulse * 5;
}

void CTFRobotDestruction_RobotAnimController::Approach( Vector& vecIn, const Vector& vecTarget, float flRate )
{
	Vector vecApproach = ( vecTarget - vecIn ) * flRate * gpGlobals->frametime;
	if ( vecApproach.LengthSqr() > ( vecIn - vecTarget ).LengthSqr() )
		vecIn = vecTarget;
	else
		vecIn += vecApproach;		
}

void CTFRobotDestruction_RobotAnimController::GetPoseParams()
{
	m_poseParams.m_nMoveX = m_pOuter->LookupPoseParameter( "move_x" );
	m_poseParams.m_nMoveY = m_pOuter->LookupPoseParameter( "move_y" );
}

IMPLEMENT_NETWORKCLASS_ALIASED( TFRobotDestruction_Robot, DT_TFRobotDestruction_Robot )

BEGIN_NETWORK_TABLE( CTFRobotDestruction_Robot, DT_TFRobotDestruction_Robot  )
#ifdef CLIENT_DLL
	RecvPropInt( RECVINFO(m_iHealth) ),
	RecvPropInt( RECVINFO(m_iMaxHealth) ),
	RecvPropInt( RECVINFO(m_eType) ),
#else
	SendPropInt(SENDINFO(m_iHealth), -1, SPROP_VARINT ),
	SendPropInt(SENDINFO(m_iMaxHealth), -1, SPROP_VARINT ),
	SendPropInt(SENDINFO(m_eType), -1, SPROP_VARINT ),
#endif
END_NETWORK_TABLE()

BEGIN_DATADESC( CTFRobotDestruction_Robot )
#ifdef GAME_DLL
	DEFINE_INPUTFUNC( FIELD_VOID, "StopAndUseComputer", InputStopAndUseComputer ),
#endif
END_DATADESC()

LINK_ENTITY_TO_CLASS( tf_robot_destruction_robot, CTFRobotDestruction_Robot );

CTFRobotDestruction_Robot::CTFRobotDestruction_Robot()
	: m_animController( this )
{
#ifdef GAME_DLL
	m_nPointsSpewed = 0;

	m_intention = new CRobotIntention( this );
	m_locomotor = new CRobotLocomotion( this );
	m_body = new CHeadlessHatmanBody( this );
	m_bIsPanicked = false;
#else
	ListenForGameEvent( "rd_robot_impact" );
#endif
}

CTFRobotDestruction_Robot::~CTFRobotDestruction_Robot()
{
#ifdef CLIENT_DLL
	m_hDamagedParticleEffect = NULL;
#else
	if ( m_hSpawn )
		m_hSpawn->ClearRobot();
	if ( m_intention )
		delete m_intention;
	if ( m_locomotor )
		delete m_locomotor;
	if ( m_body )
		delete m_body;
#endif
}

void CTFRobotDestruction_Robot::StaticPrecache()
{	
	PrecacheParticleSystem( DEATH_PARTICLE_EFFECT );
	PrecacheParticleSystem( SCORING_POINTS_PARTICLE_EFFECT );
	PrecacheParticleSystem( DAMAGED_ROBOT_PARTICLE_EFFECT );
	PrecacheScriptSound( ROBOT_DEATH_EXPLOSION );

	for( int i=0; i < ARRAYSIZE( g_RobotData ); ++i )
	{
		g_RobotData[i]->Precache();
	}
}

void CTFRobotDestruction_Robot::Precache()
{
	BaseClass::Precache();
	StaticPrecache();
}

void CTFRobotDestruction_Robot::Spawn()
{
	// Clear out the gib list and create a new one.
	m_aGibs.Purge();
	BuildGibList( m_aGibs, GetModelIndex(), 1.0f, COLLISION_GROUP_NONE );
	BuildPropList( "spawn", m_aSpawnProps, GetModelIndex(), 1.f, COLLISION_GROUP_NONE );

	BaseClass::Spawn();

	SetSolid( SOLID_BBOX );

	m_takedamage = DAMAGE_YES;
	m_nSkin = ( GetTeamNumber() == TF_TEAM_RED ) ? 0 : 1;
#ifdef GAME_DLL
	SetContextThink( &CTFRobotDestruction_Robot::UpdateAnimsThink, gpGlobals->curtime, ANIMS_THINK );

	if ( m_hGroup )
	{
		m_hGroup->UpdateState();
	}

	m_hNextPath.Set( dynamic_cast<CPathTrack*>( gEntList.FindEntityByName( NULL, m_spawnData.m_pszPathName ) ) );
	// The path needs to exist
	if ( !m_hNextPath )
	{
		UTIL_Remove( this );
	}

	if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
		CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotCreated( this );

	// Create our dispenser	
	m_pDispenser = dynamic_cast<CRobotDispenser*>( CreateEntityByName( "rd_robot_dispenser" ) );
	Assert( m_pDispenser );
	m_pDispenser->SetParent( this );
	m_pDispenser->Spawn();
	m_pDispenser->ChangeTeam( GetTeamNumber() );
	m_pDispenser->OnGoActive();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Dont collide with players
//-----------------------------------------------------------------------------
bool CTFRobotDestruction_Robot::ShouldCollide( int collisionGroup, int contentsMask ) const
{
	if ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT )
	{
		return false;
	}

	return BaseClass::ShouldCollide( collisionGroup, contentsMask );
}


#ifdef CLIENT_DLL

//-----------------------------------------------------------------------------
// Purpose: Specify where our healthbars should go over our heads
//-----------------------------------------------------------------------------
float CTFRobotDestruction_Robot::GetHealthBarHeightOffset() const
{
	return g_RobotData[ m_eType ]->GetFloatData( RobotData_t::HEALTH_BAR_OFFSET_KEY );
}


void CTFRobotDestruction_Robot::OnDataChanged( DataUpdateType_t type )
{
	BaseClass::OnDataChanged( type );

	if ( type == DATA_UPDATE_CREATED )
	{
		SetNextClientThink( CLIENT_THINK_ALWAYS );
	}

	UpdateDamagedEffects();
}

//-----------------------------------------------------------------------------
// Purpose: Play damaged effects, similar to sentries
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::UpdateDamagedEffects()
{
	// Start playing our damaged particle if we're damaged
	bool bLowHealth = GetHealth() <= (GetMaxHealth() * 0.5);
	if ( bLowHealth && !m_hDamagedParticleEffect )
	{
		m_hDamagedParticleEffect = ParticleProp()->Create( DAMAGED_ROBOT_PARTICLE_EFFECT,
														 PATTACH_ABSORIGIN_FOLLOW, 
														 INVALID_PARTICLE_ATTACHMENT, 
														 Vector(0,0,50) );

	}
	else if ( !bLowHealth && m_hDamagedParticleEffect )
	{
		ParticleProp()->StopEmission( m_hDamagedParticleEffect );
		m_hDamagedParticleEffect = NULL;
	}
}

void CTFRobotDestruction_Robot::UpdateClientSideAnimation( void )
{
	m_animController.Update();

	BaseClass::UpdateClientSideAnimation();
}

void CTFRobotDestruction_Robot::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
{
	if ( event == AE_RD_ROBOT_POP_PANELS_OFF )
	{
		CUtlVector<breakmodel_t> vecProp;
		FOR_EACH_VEC( m_aSpawnProps, i )
		{
			char pstrLowerName[ MAX_PATH ];
			memset( pstrLowerName, 0, sizeof(pstrLowerName) );
			Q_snprintf( pstrLowerName, sizeof(pstrLowerName), "%s", options );
			Q_strlower( pstrLowerName );
			if ( Q_strstr( m_aSpawnProps[i].modelName, pstrLowerName ) )
			{
				vecProp.AddToTail( m_aSpawnProps[i] );
			}
		}

		if ( vecProp.Count() )
		{
			Vector vForward, vRight, vUp;
			AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );

			Vector vecBreakVelocity = Vector(0,0,200);
			AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
			Vector vecOrigin = GetAbsOrigin() + vForward*70 + vUp*10;
			QAngle vecAngles = GetAbsAngles();
			breakablepropparams_t breakParams( vecOrigin, vecAngles, vecBreakVelocity, angularImpulse );
			breakParams.impactEnergyScale = 1.0f;
			breakParams.defBurstScale = 3.f;
			int nModelIndex = GetModelIndex();

			CreateGibsFromList( vecProp, nModelIndex, NULL, breakParams, this, -1 , false, true );
		}
	}

	BaseClass::FireEvent( origin, angles, event, options );
}

void CTFRobotDestruction_Robot::FireGameEvent( IGameEvent *pEvent )
{
	const char *pszName = pEvent->GetName();
	if ( FStrEq( pszName, "rd_robot_impact" ) )
	{
		const int index_ = pEvent->GetInt( "entindex" );
		if ( index_ == entindex() )
		{
			Vector vecImpulse( pEvent->GetFloat( "impulse_x" ), pEvent->GetFloat( "impulse_y" ), pEvent->GetFloat( "impulse_z" ) );
			m_animController.Impulse( vecImpulse.Normalized() * 20 );
		}
	}
}

 CStudioHdr* CTFRobotDestruction_Robot::OnNewModel()
 {
	 CStudioHdr *hdr = BaseClass::OnNewModel();
	 BuildPropList( "spawn", m_aSpawnProps, GetModelIndex(), 1.f, COLLISION_GROUP_NONE );

	 return hdr;
 }

#endif


#ifdef GAME_DLL
void CTFRobotDestruction_Robot::HandleAnimEvent( animevent_t *pEvent )
{
	if ((pEvent->type & AE_TYPE_NEWEVENTSYSTEM) && (pEvent->type & AE_TYPE_SERVER))
	{
	/*	if ( pEvent->event == AE_RD_ROBOT_POP_PANELS_OFF )
		{
			CUtlVector<breakmodel_t> vecProp;
			FOR_EACH_VEC( m_aSpawnProps, i )
			{
				char pstrLowerName[ MAX_PATH ];
				memset( pstrLowerName, 0, sizeof(pstrLowerName) );
				Q_snprintf( pstrLowerName, sizeof(pstrLowerName), "%s", pEvent->options );
				Q_strlower( pstrLowerName );
				if ( Q_strstr( m_aSpawnProps[i].modelName, pstrLowerName ) )
				{
					vecProp.AddToTail( m_aSpawnProps[i] );
				}
			}

			if ( vecProp.Count() )
			{
				Vector vForward, vRight, vUp;
				AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );

				Vector vecBreakVelocity = Vector(0,0,200);
				AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
				Vector vecOrigin = GetAbsOrigin() + vForward*70 + vUp*10;
				QAngle vecAngles = GetAbsAngles();
				breakablepropparams_t breakParams( vecOrigin, vecAngles, vecBreakVelocity, angularImpulse );
				breakParams.impactEnergyScale = 1.0f;

				int nModelIndex = modelinfo->GetModelIndex( STRING(GetModelName()) );
				CreateGibsFromList( vecProp, nModelIndex, NULL, breakParams, NULL, -1 , false, true );
			}
		}*/
	}
}

//-----------------------------------------------------------------------------
// Purpose: Tell the game logic we're gone
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::UpdateOnRemove( void )
{
	BaseClass::UpdateOnRemove();

	if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
	{
		CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotRemoved( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Play our death visual and audio effects
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::PlayDeathEffects()
{
	EmitSound( g_RobotData[ GetRobotSpawnData().m_eType ]->GetStringData( RobotData_t::DEATH_SOUND_KEY ) ); 
	EmitSound( ROBOT_DEATH_EXPLOSION );
	DispatchParticleEffect( DEATH_PARTICLE_EFFECT, GetAbsOrigin(), QAngle( 0,0,0 ) );
}

//-----------------------------------------------------------------------------
// Purpose: Handle getting killed
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::Event_Killed( const CTakeDamageInfo &info )
{
	// Let the game logic know that we died
	if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
	{
		CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotRemoved( this );
	}

	PlayDeathEffects();

	// Find the killer & the scorer
	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CTFPlayer *pScorer = ToTFPlayer( TFGameRules()->GetDeathScorer( pKiller, pInflictor, this ) );
	CTFPlayer *pAssister = NULL;

	if ( pScorer )
	{
		// If a player is healing the scorer, give that player credit for the assist
		CTFPlayer *pHealer = ToTFPlayer( static_cast<CBaseEntity *>( pScorer->m_Shared.GetFirstHealer() ) );
		// Must be a medic to receive a healing assist, otherwise engineers get credit for assists from dispensers doing healing.
		// Also don't give an assist for healing if the inflictor was a sentry gun, otherwise medics healing engineers get assists for the engineer's sentry kills.
		if ( pHealer && ( pHealer->GetPlayerClass()->GetClassIndex() == TF_CLASS_MEDIC ) )
		{
			pAssister = pHealer;
		}

		// Work out what killed the player, and send a message to all clients about it
		int iWeaponID;
		const char *killer_weapon_name = TFGameRules()->GetKillingWeaponName( info, NULL, &iWeaponID );
		const char *killer_weapon_log_name = killer_weapon_name;

		CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pScorer->Weapon_OwnsThisID( iWeaponID ) );
		if ( pWeapon )
		{
			CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();

			if ( pItem )
			{
				if ( pItem->GetStaticData()->GetIconClassname() )
				{
					killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				}

				if ( pItem->GetStaticData()->GetLogClassname() )
				{
					killer_weapon_log_name = pItem->GetStaticData()->GetLogClassname();
				}
			}
		}

		IGameEvent *event = gameeventmanager->CreateEvent( "rd_robot_killed" );
		if ( event )
		{
			if ( pAssister && ( pAssister != pScorer ) )
			{
				event->SetInt( "assister", pAssister->GetUserID() );
			}
			
			event->SetInt( "attacker", pScorer->GetUserID() );	// attacker
			event->SetString( "weapon", killer_weapon_name );
			event->SetString( "weapon_logclassname", killer_weapon_log_name );
			event->SetInt( "weaponid", iWeaponID );
			event->SetInt( "priority", 6 );		// HLTV event priority, not transmitted

			gameeventmanager->FireEvent( event );
		}
	}

	if ( m_hSpawn )
	{
		m_hSpawn->OnRobotKilled();
	}

	if ( m_hGroup )
	{
		m_hGroup->OnRobotKilled();
	}

	// Kings dont die right away.  Their head cracks open and they spew points out over time, then self-destruct
	if ( m_spawnData.m_eType == ROBOT_TYPE_KING )
	{
		// Change our model to be the damage king model
		SetModel( g_RobotData[ m_spawnData.m_eType ]->GetStringData( RobotData_t::DAMAGED_MODEL_KEY ) );
		ResetSequence( LookupSequence("idle") );

		m_takedamage = DAMAGE_NO;
		SetContextThink( &CTFRobotDestruction_Robot::SpewBarsThink, gpGlobals->curtime, SPEW_BARS_CONTEXT );
		SetContextThink( &CTFRobotDestruction_Robot::SelfDestructThink, gpGlobals->curtime + 5.f, SELF_DESTRUCT_THINK );

		return;
	}

	// Spew our points
	SpewBars( m_spawnData.m_nNumGibs );

	// Spew ammo gibs out
	SpewGibs();

	CBaseAnimating::Event_Killed( info );
}

//-----------------------------------------------------------------------------
// Purpose: Spew out robot gibs that give ammo
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::SpewGibs()
{
	for ( int i=0; i<m_aGibs.Count(); i++ )
	{
		CTFAmmoPack *pAmmoPack = CTFAmmoPack::Create( GetAbsOrigin() + m_aGibs[i].offset, GetAbsAngles(), this, m_aGibs[i].modelName );
		Assert( pAmmoPack );
		if ( pAmmoPack )
		{
			pAmmoPack->ActivateWhenAtRest();

			// Calculate the initial impulse on the weapon.
			Vector vecImpulse( random->RandomFloat( -0.5f, 0.5f ), random->RandomFloat( -0.5f, 0.5f ), random->RandomFloat( 0.75f, 1.25f ) );
			VectorNormalize( vecImpulse );
			// Detect the head model
			bool bIsTheHead = FStrEq( "models/bots/bot_worker/bot_worker_head_gib.mdl", m_aGibs[i].modelName );
			if ( bIsTheHead )
			{
				// Pop more up than anything
				vecImpulse[2] = 3.f;
				vecImpulse *= random->RandomFloat( tf_obj_gib_velocity_max.GetFloat() * 0.75, tf_obj_gib_velocity_max.GetFloat()  );
			}
			else
			{
				vecImpulse *= random->RandomFloat( tf_obj_gib_velocity_min.GetFloat(), tf_obj_gib_velocity_max.GetFloat() );
			}


			// Cap the impulse.
			float flSpeed = vecImpulse.Length();
			if ( flSpeed > tf_obj_gib_maxspeed.GetFloat() )
			{
				VectorScale( vecImpulse, tf_obj_gib_maxspeed.GetFloat() / flSpeed, vecImpulse );
			}

			if ( pAmmoPack->VPhysicsGetObject() )
			{
				AngularImpulse angImpulse( 0.f, random->RandomFloat( 0.f, 100.f ), 0.f );
				if ( bIsTheHead )
				{
					// Make the head spin around like a top
					angImpulse = AngularImpulse( RandomFloat(-60.f,60.f), RandomFloat(-60.f,60.f), 100000.f );
				}
				pAmmoPack->VPhysicsGetObject()->SetVelocityInstantaneous( &vecImpulse, &angImpulse );
			}

			pAmmoPack->SetInitialVelocity( vecImpulse );

			pAmmoPack->m_nSkin = ( GetTeamNumber() == TF_TEAM_RED ) ? 0 : 1;

			// Give the ammo pack some health, so that trains can destroy it.
			pAmmoPack->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
			pAmmoPack->m_takedamage = DAMAGE_YES;		
			pAmmoPack->SetHealth( 900 );
			pAmmoPack->m_bObjGib = true;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Do some special effects when we take damage
//-----------------------------------------------------------------------------
int CTFRobotDestruction_Robot::OnTakeDamage( const CTakeDamageInfo &info )
{
	// Check teams
	if ( info.GetAttacker() )
	{
		if ( InSameTeam(info.GetAttacker()) )
			return 0;
						
		CBasePlayer *pAttacker = ToBasePlayer( info.GetAttacker() );
		if ( pAttacker )
		{
			pAttacker->SetLastObjectiveTime( gpGlobals->curtime );
		}
	}

	SetContextThink( &CTFRobotDestruction_Robot::RepairSelfThink, gpGlobals->curtime + 5.f, "RepairSelfThink" );

	if ( m_bShielded )
	{
		return 0;
	}

	CTakeDamageInfo newInfo;
	newInfo = info;
	ModifyDamage( &newInfo );

	// Get our attack vectors
	Vector vecDamagePos = newInfo.GetDamagePosition();
	QAngle vecDamageAngles;
	VectorAngles( -newInfo.GetDamageForce(), vecDamageAngles );
	// Use worldspace center if no damage position (happens with flamethrowers)
	if ( vecDamagePos == vec3_origin )
	{
		vecDamagePos = WorldSpaceCenter();
	}

	// Play a spark effect
	DispatchParticleEffect( "rd_bot_impact_sparks", vecDamagePos, vecDamageAngles );

	// Send an impulse event to the client for this bot
	Vector vecImpulse( newInfo.GetDamageForce() );
	m_animController.Impulse( vecImpulse.Normalized() * 20.f );

	IGameEvent *event = gameeventmanager->CreateEvent( "rd_robot_impact" );
	if ( event )
	{
		event->SetInt( "entindex", entindex() );
		event->SetInt( "impulse_x", vecImpulse.x );
		event->SetInt( "impulse_y", vecImpulse.y );
		event->SetInt( "impulse_z", vecImpulse.z );

		gameeventmanager->FireEvent( event );
	}

	if( m_hGroup )
	{
		m_hGroup->OnRobotAttacked();
	}

	int nBaseResult = BaseClass::OnTakeDamage( newInfo );

	// Let the game logic know that we got hurt
	if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
		CTFRobotDestructionLogic::GetRobotDestructionLogic()->RobotAttacked( this );
	
	return nBaseResult;
}


void CTFRobotDestruction_Robot::ModifyDamage( CTakeDamageInfo *info ) const
{
	CTFPlayer *pAttacker = ToTFPlayer( info->GetAttacker() );
	if ( pAttacker )
	{
		float flScale = 1.f;

		if ( pAttacker->IsPlayerClass( TF_CLASS_SCOUT ) )
			flScale = 1.5f;
		else if( pAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
			flScale = 2.25f;
		else if ( pAttacker->IsPlayerClass( TF_CLASS_SPY ) )
			flScale = 2.f;
		else if ( pAttacker->IsPlayerClass( TF_CLASS_PYRO ) )
			flScale = 0.75;
		else if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
			flScale = 0.75;
		else if ( pAttacker->IsPlayerClass( TF_CLASS_MEDIC ) )
			flScale = 2.f;
			
		info->SetDamage( info->GetDamage() * flScale );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Override base traceattack to prevent visible effects from team members shooting me
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
	// Prevent team damage here so blood doesn't appear
	if ( inputInfo.GetAttacker() && InSameTeam(inputInfo.GetAttacker()) )
		return;

	AddMultiDamage( inputInfo, this );
}

void CTFRobotDestruction_Robot::UpdateAnimsThink( void )
{
	m_animController.Update();

	SetContextThink( &CTFRobotDestruction_Robot::UpdateAnimsThink, gpGlobals->curtime, ANIMS_THINK );
}

//-----------------------------------------------------------------------------
// Purpose: Change our AI state to use a computer
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::InputStopAndUseComputer( inputdata_t &inputdata )
{
	// TODO: Fire off into the AI
}

//-----------------------------------------------------------------------------
// Purpose: Shoot bars out as we die
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::SpewBars( int nNumToSpew )
{
	for( int i=0; i < nNumToSpew; ++i )
	{
		CBonusPack *pBonusPack = assert_cast< CBonusPack* >( CreateEntityByName( "item_bonuspack" ) );
		if ( pBonusPack )
		{
			pBonusPack->ChangeTeam( GetEnemyTeam( GetTeamNumber() ) );
			pBonusPack->SetDisabled( false );
			pBonusPack->SetAbsOrigin( GetAbsOrigin() + Vector(0,0,20) );
			pBonusPack->SetAbsAngles( QAngle( 0.f, RandomFloat( 0, 360.f ), 0.f ) );
			// Calculate the initial impulse on the cores
			Vector vecImpulse( random->RandomFloat( -0.5, 0.5 ), random->RandomFloat( -0.5, 0.5 ), random->RandomFloat( 1.0, 1.25 ) );
			VectorNormalize( vecImpulse );
			vecImpulse *= random->RandomFloat( 125.f, 150.f );

			// Cap the impulse.
			float flSpeed = vecImpulse.Length();
			if ( flSpeed > tf_obj_gib_maxspeed.GetFloat() )
			{
				VectorScale( vecImpulse, tf_obj_gib_maxspeed.GetFloat() / flSpeed, vecImpulse );
			}

			pBonusPack->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
			pBonusPack->AddSpawnFlags( SF_NORESPAWN );
			pBonusPack->m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;

			DispatchSpawn( pBonusPack );
			pBonusPack->DropSingleInstance( vecImpulse, NULL, 0, 0 );
			pBonusPack->SetCycle( RandomFloat( 0.f, 1.f ) );
			pBonusPack->SetGravity( 0.2f );
		}
	}
}

void CTFRobotDestruction_Robot::SpewBarsThink()
{
	int nNumToSpew = 1;
	m_nPointsSpewed += nNumToSpew;
	SpewBars( nNumToSpew );

	if ( m_nPointsSpewed >= m_spawnData.m_nNumGibs )
	{
		SelfDestructThink();
	}
	else
	{
		SetContextThink( &CTFRobotDestruction_Robot::SpewBarsThink, gpGlobals->curtime + 0.1f, SPEW_BARS_CONTEXT );
	}
}

void CTFRobotDestruction_Robot::SelfDestructThink()
{
	SpewGibs();
	SpewBars( m_spawnData.m_nNumGibs - m_nPointsSpewed );
	PlayDeathEffects();
	UTIL_Remove( this );
}


//-----------------------------------------------------------------------------
// Purpose: Repair ourselves!
//-----------------------------------------------------------------------------
void CTFRobotDestruction_Robot::RepairSelfThink()
{
	// Heal!
	int nHealth = GetHealth();
	if ( tf_rd_robot_repair_rate.GetFloat() != 0.f )
	{
		nHealth += GetMaxHealth() / tf_rd_robot_repair_rate.GetFloat();
	}
	nHealth = Min( nHealth, GetMaxHealth() );
	SetHealth( nHealth );

	// Continue to heal if we're still hurt
	if ( GetHealth() != GetMaxHealth() )
	{
		SetContextThink( &CTFRobotDestruction_Robot::RepairSelfThink, gpGlobals->curtime + 1.f, "RepairSelfThink" );
	}
}

void CTFRobotDestruction_Robot::ArriveAtPath()
{
	m_hNextPath->AcceptInput( "InPass", this, this, variant_t(), 0 );
	m_hNextPath = m_hNextPath->GetNext();
}

void CTFRobotDestruction_Robot::EnableUber()
{
	m_bShielded = true;
	m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 2 : 3;

	if ( m_hGroup )
	{
		m_hGroup->UpdateState();
	}
}

void CTFRobotDestruction_Robot::DisableUber()
{
	m_bShielded = false;
	m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;

	if ( m_hGroup )
	{
		m_hGroup->UpdateState();
	}
}

void CTFRobotDestruction_Robot::SetNewActivity( Activity activity )
{
	int nSequence = SelectWeightedSequence( activity );
	if ( nSequence )
	{
		SetSequence( nSequence );
		SetPlaybackRate( 1.0f );
		SetCycle( 0 );
		ResetSequenceInfo();
	}
}

#define CLOSE_ENOUGH_TO_PATH 50.f

//---------------------------------------------------------------------------------------------
class CRobotPatrol : public Action< CTFRobotDestruction_Robot >
{
public:
	void PlayIdleActivity( CTFRobotDestruction_Robot *pMe )
	{
		pMe->SetNewActivity( ACT_BOT_PRIMARY_MOVEMENT );
	}

	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
	{
		PlayIdleActivity( pMe );

		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > OnResume( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *interruptingAction )	
	{
		PlayIdleActivity( pMe );

		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
	{
		CPathTrack* pNextPath = pMe->GetNextPath();

		if ( pMe->IsRangeGreaterThan( pNextPath, CLOSE_ENOUGH_TO_PATH ) )
		{
			if ( m_path.GetAge() > 0.5f )
			{
				CRobotPathCost cost( pMe );
				m_path.Compute( pMe, pNextPath->GetAbsOrigin(), cost );
			}

			m_path.Update( pMe );
		}
		else
		{
			pMe->ArriveAtPath();
		}

		return Continue();
	}

	virtual const char *GetName( void ) const	{ return "Patrol"; }		// return name of this action
	PathFollower m_path;
};

class CRobotSpawn : public Action< CTFRobotDestruction_Robot >
{
	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
	{
		pMe->SetNewActivity( ACT_BOT_SPAWN );
		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
	{
		if ( pMe->IsActivityFinished() )
		{
			return ChangeTo( new CRobotPatrol, "I've finished my spawn sequence" );
		}
		
		return Continue();
	}

	EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
	{
		return TryToSustain( RESULT_CRITICAL, "I'm spawning and being attacked" );
	}

	virtual void OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction )
	{
		pMe->SetBodygroup( pMe->FindBodygroupByName( "head_shell" ), 1 );
		pMe->SetBodygroup( pMe->FindBodygroupByName( "body_shell" ), 1 );
	}

	virtual const char *GetName( void ) const	{ return "Spawn"; }		// return name of this action
};

class CRobotMaterialize : public Action< CTFRobotDestruction_Robot >
{
public:
	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
	{
		// TODO: Play the materialize anim and effects
		/*int nSequence = pMe->SelectWeightedSequence( ACT_BOT_MATERIALIZE );
		pMe->ResetSequence( nSequence );*/
		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
	{
		// TODO: Check if materialize activity is finished
		//if ( pMe->IsActivityFinished() )
		{
			return ChangeTo( new CRobotSpawn, "I've fully materialized" );
		}

		// TODO: Control the materialize anim
		
		return Continue();
	}

	virtual const char *GetName( void ) const	{ return "Materialize"; }		// return name of this action
	PathFollower m_path;
};


class CRobotPanic : public Action< CTFRobotDestruction_Robot >
{
public:
	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction );
	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval );
	virtual EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info );
	virtual void OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction );

	virtual const char *GetName( void ) const	{ return "Panic"; }

private:

	CountdownTimer m_SpeakTimer;
	CountdownTimer m_attackedTimer;
	CountdownTimer m_spinTimer;
	bool m_bSpinRight;
};

class CRobotEnterPanic : public Action< CTFRobotDestruction_Robot >
{
	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
	{
		pMe->SetNewActivity( ACT_BOT_PANIC_START );
		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
	{
		if ( pMe->IsActivityFinished() )
		{
			return ChangeTo( new CRobotPanic, "I've finished my enter panic sequence" );
		}
		
		return Continue();
	}

	EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
	{
		return TryToSustain( RESULT_CRITICAL, "I'm entering panic and being attacked" );
	}

	virtual const char *GetName( void ) const	{ return "Enter Panic"; }		// return name of this action
};

class CRobotLeavePanic : public Action< CTFRobotDestruction_Robot >
{
	virtual ActionResult< CTFRobotDestruction_Robot > OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
	{
		pMe->SetNewActivity( ACT_BOT_PANIC_END );
		return Continue();
	}

	virtual ActionResult< CTFRobotDestruction_Robot > Update( CTFRobotDestruction_Robot *pMe, float interval )
	{
		if ( pMe->IsActivityFinished() )
		{
			return Done( "I've finished my leave panic sequence" );
		}
		
		return Continue();
	}

	EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
	{
		return TryToSustain( RESULT_CRITICAL, "I'm leaving panic and being attacked" );
	}

	virtual const char *GetName( void ) const	{ return "Leave Panic"; }		// return name of this action
};

//---------------------------------------------------------------------------------------------
ActionResult< CTFRobotDestruction_Robot > CRobotPanic::OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
{
	m_bSpinRight = RandomInt(0,1) == 1; // Randomly pick which way to spin
	pMe->SetIsPanicked( true );			// Let our bot know he's panicked
	m_attackedTimer.Start( 5.f );		// We panic for 5 seconds
	m_spinTimer.Start( RandomFloat( 0.75f, 1.25f ) );			// Spin for a little bit
	pMe->GetLocomotionInterface()->SetDesiredSpeed( 150.f );	// We go fast when panicked
	DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pMe, "wheel" ); // Smoke trails on our tire when panicked
	pMe->SetNewActivity( ACT_BOT_PANIC );	// Play panicked activity

	m_SpeakTimer.Start( 3.f );
	const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
	pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::HURT_SOUND_KEY ) );
	
	return Continue();
}

ActionResult< CTFRobotDestruction_Robot > CRobotPanic::Update( CTFRobotDestruction_Robot *pMe, float interval )
{
	// If we haven't been attacked in awhile, then we're done panicking
	if ( m_attackedTimer.IsElapsed() )
	{
		return ChangeTo( new CRobotLeavePanic, "I'm done panicking" );
	}

	QAngle angles = pMe->GetLocalAngles();

	// If our spin timer is still going, then spin!
	if ( m_spinTimer.GetRemainingTime() < ( m_spinTimer.GetCountdownDuration() * 0.5f ) )
	{
		float flSpinAmt = 2500.f * gpGlobals->frametime;
		flSpinAmt *= m_bSpinRight ? 1.f : -1.f;
		angles.y += flSpinAmt;
		pMe->SetLocalAngles( angles );
	}

	// We just drive forard
	Vector vForward;
	AngleVectors( angles, &vForward );
	Vector vArrivePosition = pMe->GetAbsOrigin() + vForward * 30;

	trace_t tr;
	// See if we hit anything solid a little bit below the robot.  We dont want to jump off cliffs
	UTIL_TraceLine( vArrivePosition, vArrivePosition + Vector(0,0,-30), MASK_PLAYERSOLID, pMe, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
	if ( tr.fraction < 1.0f ) 
	{
		pMe->GetLocomotionInterface()->Approach( vArrivePosition );
	}
		
	// It's time change our spin direction, choose when to spin next, and reapply our smoke particle
	if ( m_spinTimer.IsElapsed() )
	{
		m_bSpinRight = RandomInt(0,1) == 1;
		m_spinTimer.Start( RandomFloat( 0.75f, 1.25f ) );
		DispatchParticleEffect( "rocketjump_smoke", PATTACH_POINT_FOLLOW, pMe, "wheel" );
	}

	return Continue();
}

EventDesiredResult< CTFRobotDestruction_Robot > CRobotPanic::OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
{
	if ( m_SpeakTimer.IsElapsed() )
	{
		m_SpeakTimer.Start( RandomFloat( 1.5f, 2.f ) );
		const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
		pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::HURT_SOUND_KEY ) );
	}

	m_attackedTimer.Start( m_attackedTimer.GetCountdownDuration() );
	return TryToSustain( RESULT_IMPORTANT, "I'm panicking and getting attacked" );
}

void CRobotPanic::OnEnd( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *nextAction )
{ 
	pMe->SetIsPanicked( false );
	pMe->GetLocomotionInterface()->SetDesiredSpeed( 80.f );
}


//---------------------------------------------------------------------------------------------
Action< CTFRobotDestruction_Robot > *CRobotBehavior::InitialContainedAction( CTFRobotDestruction_Robot *pMe )	
{
	return new CRobotMaterialize;
}

ActionResult< CTFRobotDestruction_Robot > CRobotBehavior::OnStart( CTFRobotDestruction_Robot *pMe, Action< CTFRobotDestruction_Robot > *priorAction )
{
	return Continue();
}

#ifdef STAGING_ONLY
ConVar sv_rd_bots_STFU( "sv_rd_bots_STFU", "0", FCVAR_ARCHIVE );
#endif
ActionResult< CTFRobotDestruction_Robot > CRobotBehavior::Update( CTFRobotDestruction_Robot *pMe, float interval )
{
	//const CKnownEntity *pThreat = pMe->GetVisionInterface()->GetPrimaryKnownThreat();
	//if ( pThreat )
	//{
	//	return SuspendFor( new CRobotAttackEnemy, "I see an enemy!" );
	//}
#ifdef STAGING_ONLY
	if ( !sv_rd_bots_STFU.GetBool() )
#endif
	{
		// We've been wandering for a bit.  Speak!
		if ( m_IdleSpeakTimer.IsElapsed() && m_SpeakTimer.IsElapsed() )
		{
			m_SpeakTimer.Start( 1.f );
			m_IdleSpeakTimer.Start( RandomFloat( 6.f, 10.f ) );
			const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
			pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::IDLE_SOUND_KEY ) ); 
		}
	}

	// Do stuff!
	return Continue();
}

EventDesiredResult< CTFRobotDestruction_Robot > CRobotBehavior::OnInjured( CTFRobotDestruction_Robot *pMe, const CTakeDamageInfo &info )
{
	return TrySuspendFor( new CRobotEnterPanic, RESULT_TRY, "I've been attacked" );
}


EventDesiredResult< CTFRobotDestruction_Robot > CRobotBehavior::OnContact( CTFRobotDestruction_Robot *pMe, CBaseEntity *pOther, CGameTrace *result )
{
	if ( m_SpeakTimer.IsElapsed() && ( pOther->IsPlayer() || dynamic_cast< CTFRobotDestruction_Robot * >( pOther ) ) )
	{
		m_SpeakTimer.Start( 3.f );

#ifdef STAGING_ONLY
		if ( !sv_rd_bots_STFU.GetBool() )
#endif
		{
			const RobotSpawnData_t & data = pMe->GetRobotSpawnData();
			pMe->EmitSound( g_RobotData[ data.m_eType ]->GetStringData( RobotData_t::COLLIDE_SOUND_KEY ) );
		}
	}

	return TryContinue( RESULT_TRY );
}


//---------------------------------------------------------------------------------------------
CRobotIntention::CRobotIntention( CTFRobotDestruction_Robot *pMe ) : IIntention( pMe )
{ 
	m_behavior = new Behavior< CTFRobotDestruction_Robot >( new CRobotBehavior ); 
}

CRobotIntention::~CRobotIntention()
{
	delete m_behavior;
}

void CRobotIntention::Reset( void )
{ 
	delete m_behavior; 
	m_behavior = new Behavior< CTFRobotDestruction_Robot >( new CRobotBehavior );
}

void CRobotIntention::Update( void )
{
	m_behavior->Update( static_cast< CTFRobotDestruction_Robot * >( GetBot() ), GetUpdateInterval() ); 
}

// is this a place we can be?
QueryResultType CRobotIntention::IsPositionAllowed( const INextBot *pMeBot, const Vector &pos ) const
{
	return ANSWER_YES;
}



//---------------------------------------------------------------------------------------------
float CRobotLocomotion::GetRunSpeed( void ) const
{
	CTFRobotDestruction_Robot *pRobotMe = static_cast< CTFRobotDestruction_Robot *>( GetBot()->GetEntity() );
	return pRobotMe->GetIsPanicked() ? 150.f : 80.f;
}

float CRobotLocomotion::GetGroundSpeed() const
{
	CTFRobotDestruction_Robot *pRobotMe = static_cast< CTFRobotDestruction_Robot *>( GetBot()->GetEntity() );
	return pRobotMe->GetIsPanicked() ? 150.f : 80.f;
}

//---------------------------------------------------------------------------------------------
// if delta Z is greater than this, we have to jump to get up
float CRobotLocomotion::GetStepHeight( void ) const
{
	return 24.0f;
}


//---------------------------------------------------------------------------------------------
// return maximum height of a jump
float CRobotLocomotion::GetMaxJumpHeight( void ) const
{
	return 40.0f;
}


//---------------------------------------------------------------------------------------------
// Return max rate of yaw rotation
float CRobotLocomotion::GetMaxYawRate( void ) const
{
	return 200.0f;
}


//---------------------------------------------------------------------------------------------
bool CRobotLocomotion::ShouldCollideWith( const CBaseEntity *object ) const
{
	return false;
}

#endif

//-----------------------------------------------------------------------------
// Robot Dispenser
//-----------------------------------------------------------------------------

BEGIN_DATADESC( CRobotDispenser )
END_DATADESC()

IMPLEMENT_NETWORKCLASS_ALIASED( RobotDispenser, DT_RobotDispenser )
LINK_ENTITY_TO_CLASS( rd_robot_dispenser, CRobotDispenser );

BEGIN_NETWORK_TABLE( CRobotDispenser, DT_RobotDispenser  )
END_NETWORK_TABLE()

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CRobotDispenser::CRobotDispenser()
{
	m_bUseGenerateMetalSound = false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CRobotDispenser::Spawn( void )
{
	// This cast is for the benefit of GCC
	m_fObjectFlags |= (int)OF_DOESNT_HAVE_A_MODEL;
	m_takedamage = DAMAGE_NO;
	m_iUpgradeLevel = 1;

	TFGameRules()->OnDispenserBuilt( this );
}

//-----------------------------------------------------------------------------
// Purpose: Finished building
//-----------------------------------------------------------------------------
void CRobotDispenser::OnGoActive( void )
{
	BaseClass::OnGoActive();

	if ( m_hTouchTrigger )
	{
		m_hTouchTrigger->SetParent( GetParent() );
	}

	SetModel( "" ); 
}

//-----------------------------------------------------------------------------
// Spawn the vgui control screens on the object
//-----------------------------------------------------------------------------
void CRobotDispenser::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
{
	// no panels
	return;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CRobotDispenser::SetModel( const char *pModel )
{
	CBaseObject::SetModel( pModel );
}


#endif