tf2/tf2_src/game/server/tf/tf_obj_dispenser.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Engineer's Dispenser
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"

#include "tf_obj_dispenser.h"
#include "engine/IEngineSound.h"
#include "tf_player.h"
#include "tf_team.h"
#include "tf_gamerules.h"
#include "vguiscreen.h"
#include "world.h"
#include "explode.h"
#include "tf_gamestats.h"
#include "tf_halloween_souls_pickup.h"
#include "tf_fx.h"

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

#define DISPENSER_MINS			Vector( -20, -20,  0 )
#define DISPENSER_MAXS			Vector(  20,  20, 55 )	// tweak me

#define MINI_DISPENSER_MINS		Vector( -20, -20,  0 )
#define MINI_DISPENSER_MAXS		Vector(  20,  20, 20 )

#define DISPENSER_TRIGGER_MINS			Vector( -70, -70,  0 )
#define DISPENSER_TRIGGER_MAXS			Vector(  70,  70, 50 )	// tweak me

#define REFILL_CONTEXT			"RefillContext"
#define DISPENSE_CONTEXT		"DispenseContext"

ConVar tf_cart_spell_drop_rate( "tf_cart_spell_drop_rate", "4" );
ConVar tf_cart_duck_drop_rate( "tf_cart_duck_drop_rate", "10", FCVAR_DEVELOPMENTONLY );
ConVar tf_cart_soul_drop_rate( "tf_cart_soul_drop_rate", "10", FCVAR_DEVELOPMENTONLY );

//-----------------------------------------------------------------------------
// Purpose: SendProxy that converts the Healing list UtlVector to entindices
//-----------------------------------------------------------------------------
void SendProxy_HealingList( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
	CObjectDispenser *pDispenser = (CObjectDispenser*)pStruct;

	// If this assertion fails, then SendProxyArrayLength_HealingArray must have failed.
	Assert( iElement < pDispenser->m_hHealingTargets.Size() );

	CBaseEntity *pEnt = pDispenser->m_hHealingTargets[iElement].Get();
	EHANDLE hOther = pEnt;

	SendProxy_EHandleToInt( pProp, pStruct, &hOther, pOut, iElement, objectID );
}

int SendProxyArrayLength_HealingArray( const void *pStruct, int objectID )
{
	CObjectDispenser *pDispenser = (CObjectDispenser*)pStruct;
	return pDispenser->m_hHealingTargets.Count();
}

IMPLEMENT_SERVERCLASS_ST( CObjectDispenser, DT_ObjectDispenser )
	SendPropInt( SENDINFO( m_iState ), 2 ),
	SendPropInt( SENDINFO( m_iAmmoMetal ), -1, SPROP_VARINT ),
	SendPropInt( SENDINFO( m_iMiniBombCounter ), -1, SPROP_VARINT ),

	SendPropArray2( 
		SendProxyArrayLength_HealingArray,
		SendPropInt("healing_array_element", 0, SIZEOF_IGNORE, NUM_NETWORKED_EHANDLE_BITS, SPROP_UNSIGNED, SendProxy_HealingList), 
		MAX_PLAYERS, 
		0, 
		"healing_array"
		)

END_SEND_TABLE()

BEGIN_DATADESC( CObjectDispenser )
	DEFINE_THINKFUNC( RefillThink ),
	DEFINE_THINKFUNC( DispenseThink ),

	// key
	DEFINE_KEYFIELD( m_iszCustomTouchTrigger, FIELD_STRING, "touch_trigger" ),

END_DATADESC()

LINK_ENTITY_TO_CLASS(obj_dispenser, CObjectDispenser);
PRECACHE_REGISTER(obj_dispenser);

// How much ammo is given our per use
#define DISPENSER_DROP_METAL		40

float g_flDispenserHealRates[4] = 
{
	0,
	10.0,
	15.0,
	20.0
};

float g_flDispenserAmmoRates[4] = 
{
	0,
	0.2,
	0.3,
	0.4
};

LINK_ENTITY_TO_CLASS( dispenser_touch_trigger, CDispenserTouchTrigger );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CObjectDispenser::CObjectDispenser()
{
	int iHealth = GetMaxHealthForCurrentLevel();
	m_hTouchTrigger = NULL;
	SetMaxHealth( iHealth );
	SetHealth( iHealth );
	UseClientSideAnimation();

	m_hTouchingEntities.Purge();
	m_bUseGenerateMetalSound = true;
	m_bThrown = false;

	m_bPlayAmmoPickupSound = true;

	SetType( OBJ_DISPENSER );
}

CObjectDispenser::~CObjectDispenser()
{
	if ( m_hTouchTrigger.Get() )
	{
		UTIL_Remove( m_hTouchTrigger );
	}

	ResetHealingTargets();

	StopSound( "Building_Dispenser.Idle" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::DetonateObject( void )
{
	// We already dying?
	if ( m_bDying )
		return;

#ifdef STAGING_ONLY
	// If we're built, explode for damage
	if ( IsMiniBuilding() && !IsCarried() && !IsBuilding() && !IsPlacing() )
	{
		Vector vecOrigin = GetAbsOrigin();
		CTraceFilterIgnorePlayers traceFilter( NULL, COLLISION_GROUP_PROJECTILE );

		// base 50 damage, scale by metal amount
		float flDamage = RemapValClamped( m_iAmmoMetal, 0, MINI_DISPENSER_MAX_METAL, 50.0f, 300.0f );
		CTakeDamageInfo info( this, GetOwner(), flDamage, DMG_BLAST );

		// Scale blast radius
		float flRadius = RemapValClamped( m_iAmmoMetal, 0, MINI_DISPENSER_MAX_METAL, 150.0f, 200.0f );
		CTFRadiusDamageInfo radiusinfo( &info, vecOrigin, flRadius, NULL, flRadius );
		TFGameRules()->RadiusDamage( radiusinfo );

		CPVSFilter filter( vecOrigin );
		TE_TFExplosion( filter, 0.0f, vecOrigin, Vector(0,0,0), TF_WEAPON_GRENADE_PIPEBOMB, kInvalidEHandleExplosion, -1, SPECIAL1, INVALID_STRING_INDEX );
	}
#endif

	TFGameRules()->OnDispenserDestroyed( this );

	BaseClass::DetonateObject();
}

//-----------------------------------------------------------------------------
void CObjectDispenser::DestroyObject( void )
{
	if ( TFGameRules() )
	{
		TFGameRules()->OnDispenserDestroyed( this );
	}

	BaseClass::DestroyObject();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::Spawn()
{
	SetModel( GetPlacementModel() );

	m_iState.Set( DISPENSER_STATE_IDLE );

	SetTouch( &CObjectDispenser::Touch );

	BaseClass::Spawn();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::FirstSpawn()
{
	SetSolid( SOLID_BBOX );

	bool bShouldBeMini = ShouldBeMiniBuilding( GetOwner() );

	UTIL_SetSize(this,
		bShouldBeMini ? MINI_DISPENSER_MINS : DISPENSER_MINS,
		bShouldBeMini ? MINI_DISPENSER_MAXS : DISPENSER_MAXS );

	m_takedamage = DAMAGE_YES;
	m_iAmmoMetal = 0;

	int iHealth = GetMaxHealthForCurrentLevel();

	SetMaxHealth( iHealth );
	SetHealth( iHealth );

	BaseClass::FirstSpawn();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char* CObjectDispenser::GetBuildingModel( int iLevel )
{
#ifdef STAGING_ONLY
	if ( ShouldBeMiniBuilding( GetOwner() ) )
	{
		return MINI_DISPENSER_MODEL_BUILDING;
	}
	else
#endif // STAGING_ONLY
	{
		switch ( iLevel )
		{
		case 1:
			return DISPENSER_MODEL_BUILDING;
			break;
		case 2:
			return DISPENSER_MODEL_BUILDING_LVL2;
			break;
		case 3:
			return DISPENSER_MODEL_BUILDING_LVL3;
			break;
		default:
			return DISPENSER_MODEL_BUILDING;
			break;
		}
	}

	Assert( 0 );
	return DISPENSER_MODEL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char* CObjectDispenser::GetFinishedModel( int iLevel )
{
#ifdef STAGING_ONLY
	if ( IsMiniBuilding() )
	{
		return MINI_DISPENSER_MODEL;
	}
	else
#endif // STAGING_ONLY
	{
		switch ( iLevel )
		{
		case 1:
			return DISPENSER_MODEL;
			break;
		case 2:
			return DISPENSER_MODEL_LVL2;
			break;
		case 3:
			return DISPENSER_MODEL_LVL3;
			break;
		default:
			return DISPENSER_MODEL;
			break;
		}
	}

	Assert( 0 );
	return DISPENSER_MODEL;
}

const char* CObjectDispenser::GetPlacementModel()
{
	return /*IsMiniBuilding() ? MINI_DISPENSER_MODEL_PLACEMENT :*/ DISPENSER_MODEL_PLACEMENT;
}

void CObjectDispenser::StartPlacement( CTFPlayer *pPlayer )
{
	BaseClass::StartPlacement( pPlayer );
}

//-----------------------------------------------------------------------------
// Purpose: Start building the object
//-----------------------------------------------------------------------------
bool CObjectDispenser::StartBuilding( CBaseEntity *pBuilder )
{
	SetStartBuildingModel();

	// Have to re-call this in case the player changed their weapon
	// between StartPlacement and StartBuilding.
	MakeMiniBuilding( GetBuilder() );

	CreateBuildPoints();

	TFGameRules()->OnDispenserBuilt( this );

	bool bIsCarried = IsCarried();

	bool bStartBuildingResult = BaseClass::StartBuilding( pBuilder );

	if ( bIsCarried )
	{
		OnEndBeingCarried( pBuilder );
	}
	
	return bStartBuildingResult;
}

void CObjectDispenser::SetStartBuildingModel( void )
{
	SetModel( GetBuildingModel( 1 ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::MakeMiniBuilding( CTFPlayer* pPlayer )
{
	if ( !ShouldBeMiniBuilding( pPlayer ) || IsMiniBuilding() )
		return;

	BaseClass::MakeMiniBuilding( pPlayer );

	int iHealth = GetMaxHealthForCurrentLevel();

	SetMaxHealth( iHealth );
	SetHealth( iHealth );
}

//-----------------------------------------------------------------------------
// Purpose: Raises the Dispenser one level
//-----------------------------------------------------------------------------
void CObjectDispenser::StartUpgrading( void )
{
	// m_iUpgradeLevel is incremented in BaseClass::StartUpgrading(), 
	// but we need to set the model before calling it so SetActivity() will be successful
	SetModel( GetBuildingModel( m_iUpgradeLevel+1 ) );

	// clear our healing list, everyone will be 
	// added again at the new heal rate in DispenseThink()
	ResetHealingTargets();

	BaseClass::StartUpgrading();

	m_iState.Set( DISPENSER_STATE_UPGRADING );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::FinishUpgrading( void )
{
	m_iState.Set( DISPENSER_STATE_IDLE );

	BaseClass::FinishUpgrading();

	if ( m_iUpgradeLevel > 1 )
	{
		SetModel( GetFinishedModel( m_iUpgradeLevel ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::SetModel( const char *pModel )
{
	BaseClass::SetModel( pModel );

		// Reset this after model change
#ifdef STAGING_ONLY
		UTIL_SetSize(this,
			IsMiniBuilding() ? MINI_DISPENSER_MINS : DISPENSER_MINS,
			IsMiniBuilding() ? MINI_DISPENSER_MAXS : DISPENSER_MAXS );
#else
		UTIL_SetSize( this,
			DISPENSER_MINS,
			DISPENSER_MAXS );
#endif // STAGING_ONLY
	ResetSequenceInfo();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::InitializeMapPlacedObject( void )
{
	// make sure we are using an appropriate model so that the control panels are in the right place
	SetModel( GetFinishedModel( 1 ) );

	BaseClass::InitializeMapPlacedObject();
}

bool CObjectDispenser::ShouldBeMiniBuilding( CTFPlayer* pPlayer )
{
#ifdef STAGING_ONLY
	int nMiniDispenserEnabled = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( GetOwner(), nMiniDispenserEnabled, allows_building_mini_dispenser );
	return nMiniDispenserEnabled != 0;
#else
	return false;
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CObjectDispenser::GetMaxUpgradeLevel()
{
#ifdef STAGING_ONLY
	if ( IsMiniBuilding() )
		return DISPENSER_MINI_MAX_LEVEL;
#endif // STAGING_ONLY

	return BaseClass::GetMaxUpgradeLevel();
}

//-----------------------------------------------------------------------------
// Purpose: Finished building
//-----------------------------------------------------------------------------
void CObjectDispenser::OnGoActive( void )
{
	SetModel( GetFinishedModel( 1 ) );

	CreateBuildPoints();

	ReattachChildren();

	// Put some ammo in the Dispenser
	if ( !m_bCarryDeploy && !IsMiniBuilding() )
	{
		m_iAmmoMetal = TFGameRules()->IsQuickBuildTime() ? DISPENSER_MAX_METAL_AMMO : 25;
	}

	// Begin thinking
	SetContextThink( &CObjectDispenser::RefillThink, gpGlobals->curtime + 3, REFILL_CONTEXT );
	SetContextThink( &CObjectDispenser::DispenseThink, gpGlobals->curtime + 0.1, DISPENSE_CONTEXT );

	m_flNextAmmoDispense = gpGlobals->curtime + 0.5;

	if ( m_hTouchTrigger.Get() && dynamic_cast<CObjectCartDispenser*>(this) != NULL )
	{
		UTIL_Remove( m_hTouchTrigger.Get() );
		m_hTouchTrigger = NULL;
	}

	float flRadius = GetDispenserRadius();
	
	if ( m_iszCustomTouchTrigger != NULL_STRING )
	{
		m_hTouchTrigger = dynamic_cast<CDispenserTouchTrigger *> ( gEntList.FindEntityByName( NULL, m_iszCustomTouchTrigger ) );

		if ( m_hTouchTrigger.Get() != NULL )
		{
			m_hTouchTrigger->SetOwnerEntity( this );	//owned
		}
	}

	if ( m_hTouchTrigger.Get() == NULL )
	{
		m_hTouchTrigger = CBaseEntity::Create( "dispenser_touch_trigger", GetAbsOrigin(), vec3_angle, this );
		UTIL_SetSize(m_hTouchTrigger.Get(), Vector(-flRadius,-flRadius,-flRadius), Vector(flRadius,flRadius,flRadius) );
		m_hTouchTrigger->SetSolid(SOLID_BBOX);
	}

	Assert( m_hTouchTrigger.Get() );

	BaseClass::OnGoActive();

	PlayActiveSound();
}

void CObjectDispenser::PlayActiveSound()
{
	EmitSound( "Building_Dispenser.Idle" );
}

//-----------------------------------------------------------------------------
// Spawn the vgui control screens on the object
//-----------------------------------------------------------------------------
void CObjectDispenser::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
{
	// Panels 0 and 1 are both control panels for now
	if ( nPanelIndex == 0 || nPanelIndex == 1 )
	{
		if ( GetTeamNumber() == TF_TEAM_RED )
		{
			pPanelName = "screen_obj_dispenser_red";
		}
		else
		{
			pPanelName = "screen_obj_dispenser_blue";
		}
	}
	else
	{
		BaseClass::GetControlPanelInfo( nPanelIndex, pPanelName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::Precache()
{
	BaseClass::Precache();

	int iModelIndex;

	PrecacheModel( DISPENSER_MODEL_PLACEMENT );

	iModelIndex = PrecacheModel( DISPENSER_MODEL_BUILDING );
	PrecacheGibsForModel( iModelIndex );

	iModelIndex = PrecacheModel( DISPENSER_MODEL );
	PrecacheGibsForModel( iModelIndex );

	iModelIndex = PrecacheModel( DISPENSER_MODEL_BUILDING_LVL2 );
	PrecacheGibsForModel( iModelIndex );

	iModelIndex = PrecacheModel( DISPENSER_MODEL_LVL2 );
	PrecacheGibsForModel( iModelIndex );

	iModelIndex = PrecacheModel( DISPENSER_MODEL_BUILDING_LVL3 );
	PrecacheGibsForModel( iModelIndex );

	iModelIndex = PrecacheModel( DISPENSER_MODEL_LVL3 );
	PrecacheGibsForModel( iModelIndex );

#ifdef STAGING_ONLY
	PrecacheGibsForModel( PrecacheModel( MINI_DISPENSER_MODEL_PLACEMENT ) );
	PrecacheGibsForModel( PrecacheModel( MINI_DISPENSER_MODEL_BUILDING ) );
	PrecacheGibsForModel( PrecacheModel( MINI_DISPENSER_MODEL ) );
#endif // STAGING_ONLY

	PrecacheVGuiScreen( "screen_obj_dispenser_blue" );
	PrecacheVGuiScreen( "screen_obj_dispenser_red" );

	PrecacheScriptSound( "Building_Dispenser.Idle" );
	PrecacheScriptSound( "Building_Dispenser.GenerateMetal" );
	PrecacheScriptSound( "Building_Dispenser.Heal" );

	PrecacheParticleSystem( "dispenser_heal_red" );
	PrecacheParticleSystem( "dispenser_heal_blue" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CObjectDispenser::DispenseAmmo( CTFPlayer *pPlayer )
{
	int iTotalPickedUp = 0;
	int iAmmoToAdd = 0;

	int nNoPrimaryAmmoFromDispensersWhileActive = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer->GetActiveWeapon(), nNoPrimaryAmmoFromDispensersWhileActive, no_primary_ammo_from_dispensers );

#ifdef STAGING_ONLY
	float flAmmoRate = IsMiniBuilding() ? DISPENSER_MINI_AMMO_RATE : g_flDispenserAmmoRates[GetUpgradeLevel()];
#else
	float flAmmoRate = g_flDispenserAmmoRates[GetUpgradeLevel()];
#endif

	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), flAmmoRate, mult_dispenser_rate );

	if ( nNoPrimaryAmmoFromDispensersWhileActive == 0 )
	{
		// primary
		iAmmoToAdd = (int)( pPlayer->GetMaxAmmo( TF_AMMO_PRIMARY ) * flAmmoRate );
		iTotalPickedUp += pPlayer->GiveAmmo( iAmmoToAdd, TF_AMMO_PRIMARY, !m_bPlayAmmoPickupSound, kAmmoSource_DispenserOrCart );
	}

	// secondary
	iAmmoToAdd = (int)( pPlayer->GetMaxAmmo( TF_AMMO_SECONDARY ) * flAmmoRate );
	iTotalPickedUp += pPlayer->GiveAmmo( iAmmoToAdd, TF_AMMO_SECONDARY, !m_bPlayAmmoPickupSound, kAmmoSource_DispenserOrCart );

	// metal
	int iNoMetalFromDispenserWhileActive = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer->GetActiveWeapon(), iNoMetalFromDispenserWhileActive, no_metal_from_dispensers_while_active );
	if ( iNoMetalFromDispenserWhileActive == 0 )
	{
		iTotalPickedUp += DispenseMetal( pPlayer );
	}

	if ( iTotalPickedUp > 0 )
	{
		if ( m_bPlayAmmoPickupSound )
		{
			EmitSound( "BaseCombatCharacter.AmmoPickup" );
		}

		CTFPlayer *pOwner = GetOwner();
		if ( pOwner && pOwner != pPlayer )
		{
			// This is crude; it doesn't account for the value difference in resupplying rockets vs pistol bullets.
			// Still, it's better than nothing when trying to measure the value classes generate.
			if ( TFGameRules() && 
				 TFGameRules()->GameModeUsesUpgrades() &&
				 TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
			{
				CTF_GameStats.Event_PlayerAwardBonusPoints( pOwner, pPlayer, 1 );
			}
		}

		return true;
	}

	// return false if we didn't pick up anything
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CObjectDispenser::DispenseMetal( CTFPlayer *pPlayer )
{
	int iMetalToGive = DISPENSER_DROP_METAL + ((GetUpgradeLevel()-1) * 10);
	int iMetal = pPlayer->GiveAmmo( Min( m_iAmmoMetal.Get(), iMetalToGive ), TF_AMMO_METAL, false, kAmmoSource_DispenserOrCart );
	m_iAmmoMetal -= iMetal;

	return iMetal;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::RefillThink( void )
{
	if ( IsCarried() )
		return;

	SetContextThink( &CObjectDispenser::RefillThink, gpGlobals->curtime + 6, REFILL_CONTEXT );

	if ( IsDisabled() )
	{
		return;
	}

	// Auto-refill half the amount as tfc, but twice as often
	if ( m_iAmmoMetal < DISPENSER_MAX_METAL_AMMO )
	{
		int iMetal = (DISPENSER_MAX_METAL_AMMO * 0.1) + ((GetUpgradeLevel()-1) * 10);

		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), iMetal, mult_dispenser_rate );

		m_iAmmoMetal = Min( m_iAmmoMetal + iMetal, DISPENSER_MAX_METAL_AMMO );

		if ( m_bUseGenerateMetalSound )
		{
			EmitSound( "Building_Dispenser.GenerateMetal" );
		}
	}
}


//-----------------------------------------------------------------------------
// Generate ammo over time
//-----------------------------------------------------------------------------
void CObjectDispenser::DispenseThink( void )
{
	if ( IsCarried() )
		return;

	if ( IsDisabled() )
	{
		// Don't heal or dispense ammo
		SetContextThink( &CObjectDispenser::DispenseThink, gpGlobals->curtime + 0.1, DISPENSE_CONTEXT );

		// stop healing everyone
		ResetHealingTargets();
		return;
	}
	
	float flRadius = GetDispenserRadius();

	if ( m_flNextAmmoDispense <= gpGlobals->curtime )
	{
		int iNumNearbyPlayers = 0;

		if ( GetOwner() )
		{
			// find players in sphere, that are visible
			if ( ( flRadius != m_flPrevRadius ) && m_hTouchTrigger.Get() )
			{
				UTIL_SetSize( m_hTouchTrigger.Get(), Vector( -flRadius, -flRadius, -flRadius ), Vector( flRadius, flRadius, flRadius ) );	
			}
		}

		m_flPrevRadius = flRadius;

		Vector vecOrigin = GetAbsOrigin() + Vector(0,0,32);

		CBaseEntity *pListOfNearbyEntities[32];
		int iNumberOfNearbyEntities = UTIL_EntitiesInSphere( pListOfNearbyEntities, ARRAYSIZE( pListOfNearbyEntities ), vecOrigin, flRadius, FL_CLIENT );
		for ( int i=0;i<iNumberOfNearbyEntities;i++ )
		{
			CTFPlayer *pPlayer = ToTFPlayer( pListOfNearbyEntities[i] );

			if ( !pPlayer || !pPlayer->IsAlive() )
				continue;

			if ( pPlayer->GetTeamNumber() != GetTeamNumber() )
			{
				if ( !pPlayer->IsPlayerClass( TF_CLASS_SPY ) || ( pPlayer->m_Shared.GetDisguiseTeam() != GetTeamNumber() ) )
					continue;
			}

			DispenseAmmo( pPlayer );

			iNumNearbyPlayers++;
		}

		// Try to dispense more often when no players are around so we 
		// give it as soon as possible when a new player shows up
#ifdef STAGING_ONLY
		float flNextAmmoDelay = IsMiniBuilding() ? DISPENSER_MINI_AMMO_THINK : 1.0;
#else
		float flNextAmmoDelay = 1.0;
#endif
		m_flNextAmmoDispense = gpGlobals->curtime + ( ( iNumNearbyPlayers > 0 ) ? flNextAmmoDelay : 0.1 );
	}	

	// for each player in touching list
	int iSize = m_hTouchingEntities.Count();
	bool bIsAnyTeammateTouching = false;

	if ( m_hTouchTrigger )
	{
		for ( int i = iSize-1; i >= 0; i-- )
		{
			EHANDLE hOther = m_hTouchingEntities[i];

			CBaseEntity *pEnt = hOther.Get();
			if ( !pEnt )
				continue;

			// stop touching and healing a dead entity, or one that is grossly out of range (EndTouch() can be flakey)
			float flDistSqr = (m_hTouchTrigger->WorldSpaceCenter() - pEnt->WorldSpaceCenter()).LengthSqr();
			Vector vecMins, vecMaxs;
			m_hTouchTrigger->GetCollideable()->WorldSpaceSurroundingBounds( &vecMins, &vecMaxs );
			float flDoubleRadiusSqr = ( vecMaxs - vecMins ).LengthSqr();
			if ( !pEnt->IsAlive() || ( flDistSqr > flDoubleRadiusSqr ) )
			{
				m_hTouchingEntities.FindAndRemove( hOther );
				StopHealing( pEnt );
				continue;
			}

			bIsAnyTeammateTouching |= ( pEnt->IsPlayer() && pEnt->GetTeamNumber() == GetTeamNumber() );


			bool bHealingTarget = IsHealingTarget( pEnt );
			bool bValidHealTarget = CouldHealTarget( pEnt );

			if ( bHealingTarget && !bValidHealTarget )
			{
				// if we can't see them, remove them from healing list
				// does nothing if we are not healing them already
				StopHealing( pEnt );
			}
			else if ( !bHealingTarget && bValidHealTarget )
			{
				// if we can see them, add to healing list	
				// does nothing if we are healing them already
				StartHealing( pEnt );
			}	
		}
	}

	if ( bIsAnyTeammateTouching )
	{
		if ( !m_spellTimer.HasStarted() )
		{
			m_spellTimer.Start( tf_cart_spell_drop_rate.GetFloat() );
		}

		if ( !m_duckTimer.HasStarted() )
		{
			m_duckTimer.Start( tf_cart_duck_drop_rate.GetFloat() );
		}

		if ( !m_soulTimer.HasStarted() )
		{
			m_soulTimer.Start( tf_cart_soul_drop_rate.GetFloat() );
		}
	}
	else
	{
		m_spellTimer.Invalidate();
		m_duckTimer.Invalidate();
		m_soulTimer.Invalidate();
	}

	if ( m_spellTimer.HasStarted() && m_spellTimer.IsElapsed() )
	{
		m_spellTimer.Start( tf_cart_spell_drop_rate.GetFloat() );
		DropSpellPickup();
	}

	if ( m_duckTimer.HasStarted() && m_duckTimer.IsElapsed() )
	{
		m_duckTimer.Start( tf_cart_duck_drop_rate.GetFloat() );
		DropDuckPickup();
	}

	if ( m_soulTimer.HasStarted() && m_soulTimer.IsElapsed() )
	{
		m_soulTimer.Start( tf_cart_soul_drop_rate.GetFloat() );
		DispenseSouls();
	}

	SetContextThink( &CObjectDispenser::DispenseThink, gpGlobals->curtime + 0.1, DISPENSE_CONTEXT );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::StartTouch( CBaseEntity *pOther )
{
	// add to touching entities
	EHANDLE hOther = pOther;
	m_hTouchingEntities.AddToTail( hOther );

	if ( !IsBuilding() && !IsDisabled() && CouldHealTarget( pOther ) && !IsHealingTarget( pOther ) )
	{
		// try to start healing them
		StartHealing( pOther );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::Touch( CBaseEntity *pOther )
{
	// We dont want to touch these
	if ( pOther->IsSolidFlagSet( FSOLID_TRIGGER | FSOLID_VOLUME_CONTENTS ) )
		return;

	// Handle hitting skybox (disappear).
	const trace_t *pTrace = &CBaseEntity::GetTouchTrace();
	if( pTrace->surface.flags & SURF_SKY )
	{
		UTIL_Remove( this );
		return;
	}

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::EndTouch( CBaseEntity *pOther )
{
	// remove from touching entities
	EHANDLE hOther = pOther;
	m_hTouchingEntities.FindAndRemove( hOther );

	// remove from healing list
	StopHealing( pOther );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectDispenser::ResetHealingTargets( void )
{
	// tell all the players we're not healing them anymore
	for ( int i = m_hHealingTargets.Count()-1 ; i >= 0 ; i-- )
	{
		EHANDLE hEnt = m_hHealingTargets[i];
		CBaseEntity *pOther = hEnt.Get();

		if ( pOther )
		{
			StopHealing( pOther );
		}
	}

}

//-----------------------------------------------------------------------------
// Purpose: Try to start healing this target
//-----------------------------------------------------------------------------
float CObjectDispenser::GetHealRate() const
{
#ifdef STAGING_ONLY
	float flHealRate = IsMiniBuilding() ? DISPENSER_MINI_HEAL_RATE : g_flDispenserHealRates[GetUpgradeLevel()];
#else
	float flHealRate = g_flDispenserHealRates[GetUpgradeLevel()];
#endif
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), flHealRate, mult_dispenser_rate );

	return flHealRate;
}

//-----------------------------------------------------------------------------
// Purpose: Try to start healing this target
//-----------------------------------------------------------------------------
void CObjectDispenser::StartHealing( CBaseEntity *pOther )
{
	if ( IsCarried() )
		return;

	AddHealingTarget( pOther );

	CTFPlayer *pPlayer = ToTFPlayer( pOther );

	if ( pPlayer )
	{
		float flHealRate = GetHealRate();
		float flOverhealBonus = 1.0;
		pPlayer->m_Shared.Heal( this, flHealRate, flOverhealBonus, 1.0, true, GetBuilder() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Stop healing this target
//-----------------------------------------------------------------------------
void CObjectDispenser::StopHealing( CBaseEntity *pOther )
{
	if ( RemoveHealingTarget( pOther ) )
	{
		CTFPlayer *pPlayer = ToTFPlayer( pOther );

		if ( pPlayer )
		{
			float flHealingDone = pPlayer->m_Shared.StopHealing( this );
			if ( GetBuilder() && pOther != GetBuilder() && flHealingDone > 0 )
			{
				GetBuilder()->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_DISPENSER_HEAL_GRIND, floor( flHealingDone ) );

				if ( GetBuilder()->GetTeam() == pOther->GetTeam() )
				{
					// Strange Health Provided to Allies
					EconEntity_OnOwnerKillEaterEvent( 
						dynamic_cast<CEconEntity *>( GetBuilder()->GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA ) ),
						GetBuilder(),
						pPlayer,
						kKillEaterEvent_HealingProvided,
						(int)flHealingDone
					);
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Is this a valid heal target? and not already healing them?
//-----------------------------------------------------------------------------
bool CObjectDispenser::CouldHealTarget( CBaseEntity *pTarget )
{
	if ( !HasSpawnFlags( SF_DISPENSER_IGNORE_LOS ) && !pTarget->FVisible( this, MASK_BLOCKLOS ) )
		return false;

	if ( pTarget->IsPlayer() && pTarget->IsAlive() )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( pTarget );

		// Don't heal while in purgatory.  Players take damage constantly while down there in
		// order to flush them out.  If we're healing players down there, that goes against
		// the purpose of the damage.
		if ( pTFPlayer->IsInPurgatory() )
			return false;

		// don't heal enemies unless they are disguised as our team
		int iTeam = GetTeamNumber();
		int iPlayerTeam = pTFPlayer->GetTeamNumber();

		if ( iPlayerTeam != iTeam && pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
		{
			iPlayerTeam = pTFPlayer->m_Shared.GetDisguiseTeam();
		}

		if ( iPlayerTeam != iTeam )
		{
			return false;
		}

		if ( HasSpawnFlags( SF_DISPENSER_DONT_HEAL_DISGUISED_SPIES ) )
		{
			// if they're invis, no heals
			if ( pTFPlayer->m_Shared.IsStealthed() )
			{
				return false;
			}

			// if they're disguised as enemy
			if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) &&
				 pTFPlayer->m_Shared.GetDisguiseTeam() != iTeam )
			{
				return false;
			}
		}

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CObjectDispenser::GetDispenserRadius( void )
{
	float flRadius = 64.f;

	if ( GetOwner() )
	{
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), flRadius, mult_dispenser_radius );
	}

	return flRadius;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectDispenser::AddHealingTarget( CBaseEntity *pOther )
{
	// add to tail
	EHANDLE hOther = pOther;
	m_hHealingTargets.AddToTail( hOther );
	NetworkStateChanged();

	// check how many healing targets we now have and possibly award an achievement
	if ( m_hHealingTargets.Count() >= 3 && GetBuilder() )
	{
		GetBuilder()->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_DISPENSER_HEAL_GROUP );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CObjectDispenser::RemoveHealingTarget( CBaseEntity *pOther )
{
	// remove
	EHANDLE hOther = pOther;
	bool bFound = m_hHealingTargets.FindAndRemove( hOther );
	NetworkStateChanged();

	return bFound;
}

//-----------------------------------------------------------------------------
// Purpose: Are we healing this target already
//-----------------------------------------------------------------------------
bool CObjectDispenser::IsHealingTarget( CBaseEntity *pTarget )
{
	EHANDLE hOther = pTarget;
	return m_hHealingTargets.HasElement( hOther );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CObjectDispenser::DrawDebugTextOverlays(void) 
{
	int text_offset = BaseClass::DrawDebugTextOverlays();

	if (m_debugOverlays & OVERLAY_TEXT_BIT) 
	{
		char tempstr[512];
		Q_snprintf( tempstr, sizeof( tempstr ),"Metal: %d", m_iAmmoMetal.Get() );
		EntityText(text_offset,tempstr,0);
		text_offset++;
	}
	return text_offset;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
void CObjectDispenser::MakeCarriedObject( CTFPlayer *pCarrier )
{
	if ( m_hTouchTrigger.Get() )
	{
		UTIL_Remove( m_hTouchTrigger );
	}

	ResetHealingTargets();

	m_hTouchingEntities.Purge();

	StopSound( "Building_Dispenser.Idle" );

	BaseClass::MakeCarriedObject( pCarrier );
}


//-----------------------------------------------------------------------------
// Cart Dispenser
//-----------------------------------------------------------------------------

BEGIN_DATADESC( CObjectCartDispenser )
	DEFINE_INPUTFUNC( FIELD_INTEGER, "FireHalloweenBonus", InputFireHalloweenBonus ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetDispenserLevel", InputSetDispenserLevel ),
 	DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
	DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
END_DATADESC()

IMPLEMENT_SERVERCLASS_ST( CObjectCartDispenser, DT_ObjectCartDispenser )
END_SEND_TABLE()

LINK_ENTITY_TO_CLASS( mapobj_cart_dispenser, CObjectCartDispenser );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CObjectCartDispenser::CObjectCartDispenser()
{
	m_bUseGenerateMetalSound = false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CObjectCartDispenser::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 CObjectCartDispenser::OnGoActive( void )
{
	BaseClass::OnGoActive();

	SetModel( "" ); 
}

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

//-----------------------------------------------------------------------------
// Don't decrement our metal count
//-----------------------------------------------------------------------------
int CObjectCartDispenser::DispenseMetal( CTFPlayer *pPlayer )
{
	int iMetal = pPlayer->GiveAmmo( MIN( m_iAmmoMetal, DISPENSER_DROP_METAL ), TF_AMMO_METAL, false, kAmmoSource_DispenserOrCart );
	return iMetal;
}


void CObjectCartDispenser::DropSpellPickup()
{
	if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		TFGameRules()->DropSpellPickup( GetAbsOrigin() );
	}
}

void CObjectCartDispenser::DropDuckPickup()
{
	if ( TFGameRules()->IsHolidayActive( kHoliday_EOTL ) && TFGameRules()->ShouldDropBonusDuck() )
	{
		TFGameRules()->DropBonusDuck( GetAbsOrigin() );
	}
}

void CObjectCartDispenser::DispenseSouls()
{
	// Give a soul to the entire team
	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		TFGameRules()->DropHalloweenSoulPackToTeam( 1, GetAbsOrigin(), GetTeamNumber(), TEAM_SPECTATOR );
	}
}

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

//-----------------------------------------------------------------------------
// Purpose: Give players near the dispenser a bonus
//-----------------------------------------------------------------------------
void CObjectCartDispenser::InputFireHalloweenBonus( inputdata_t &inputdata )
{
	for ( int i = m_hHealingTargets.Count()-1 ; i >= 0 ; i-- )
	{
		EHANDLE hEnt = m_hHealingTargets[i];
		CTFPlayer *pTFPlayer = ToTFPlayer( hEnt.Get() );

		if ( pTFPlayer )
		{
			pTFPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, inputdata.value.Int() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectCartDispenser::InputSetDispenserLevel( inputdata_t &inputdata )
{
	int iLevel = inputdata.value.Int();

	if ( iLevel >= 1 && iLevel <= 3 )
	{
		m_iUpgradeLevel = iLevel;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectCartDispenser::InputEnable( inputdata_t &inputdata )
{
	SetDisabled( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectCartDispenser::InputDisable( inputdata_t &inputdata )
{
	SetDisabled( true );
}