1262 lines
36 KiB
C++
1262 lines
36 KiB
C++
//========= 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 );
|
|
}
|
|
|
|
|