First version of the SOurce SDK 2013

1 files changed, 734 insertions, 0 deletions

diff --git a/mp/src/game/server/basecombatweapon.cpp b/mp/src/game/server/basecombatweapon.cpp
new file mode 100644
index 00000000..8a44673f
--- /dev/null
+++ b/mp/src/game/server/basecombatweapon.cpp
@@ -0,0 +1,734 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+//=============================================================================//

+

+#include "cbase.h"

+#include "ai_basenpc.h"

+#include "animation.h"

+#include "basecombatweapon.h"

+#include "player.h"			// For gEvilImpulse101 / CBasePlayer

+#include "gamerules.h"		// For g_pGameRules

+#include <KeyValues.h>

+#include "ammodef.h"

+#include "baseviewmodel.h"

+#include "in_buttons.h"

+#include "soundent.h"

+#include "weapon_parse.h"

+#include "game.h"

+#include "engine/IEngineSound.h"

+#include "sendproxy.h"

+#include "tier1/strtools.h"

+#include "vphysics/constraints.h"

+#include "npcevent.h"

+#include "igamesystem.h"

+#include "collisionutils.h"

+#include "iservervehicle.h"

+#include "func_break.h"

+

+#ifdef HL2MP

+	#include "hl2mp_gamerules.h"

+#endif

+

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

+#include "tier0/memdbgon.h"

+

+extern int	gEvilImpulse101;		// In Player.h

+

+// -----------------------------------------

+//	Sprite Index info

+// -----------------------------------------

+short		g_sModelIndexLaser;			// holds the index for the laser beam

+const char	*g_pModelNameLaser = "sprites/laserbeam.vmt";

+short		g_sModelIndexLaserDot;		// holds the index for the laser beam dot

+short		g_sModelIndexFireball;		// holds the index for the fireball

+short		g_sModelIndexSmoke;			// holds the index for the smoke cloud

+short		g_sModelIndexWExplosion;	// holds the index for the underwater explosion

+short		g_sModelIndexBubbles;		// holds the index for the bubbles model

+short		g_sModelIndexBloodDrop;		// holds the sprite index for the initial blood

+short		g_sModelIndexBloodSpray;	// holds the sprite index for splattered blood

+

+

+ConVar weapon_showproficiency( "weapon_showproficiency", "0" );

+extern ConVar ai_debug_shoot_positions;

+

+//-----------------------------------------------------------------------------

+// Purpose: Precache global weapon sounds

+//-----------------------------------------------------------------------------

+void W_Precache(void)

+{

+	PrecacheFileWeaponInfoDatabase( filesystem, g_pGameRules->GetEncryptionKey() );

+

+

+

+#ifdef HL1_DLL

+	g_sModelIndexWExplosion = CBaseEntity::PrecacheModel ("sprites/WXplo1.vmt");// underwater fireball

+	g_sModelIndexBloodSpray = CBaseEntity::PrecacheModel ("sprites/bloodspray.vmt"); // initial blood

+	g_sModelIndexBloodDrop = CBaseEntity::PrecacheModel ("sprites/blood.vmt"); // splattered blood 

+	g_sModelIndexLaserDot = CBaseEntity::PrecacheModel("sprites/laserdot.vmt");

+#endif // HL1_DLL

+

+#ifndef TF_DLL

+	g_sModelIndexFireball = CBaseEntity::PrecacheModel ("sprites/zerogxplode.vmt");// fireball

+

+	g_sModelIndexSmoke = CBaseEntity::PrecacheModel ("sprites/steam1.vmt");// smoke

+	g_sModelIndexBubbles = CBaseEntity::PrecacheModel ("sprites/bubble.vmt");//bubbles

+	g_sModelIndexLaser = CBaseEntity::PrecacheModel( (char *)g_pModelNameLaser );

+

+	PrecacheParticleSystem( "blood_impact_red_01" );

+	PrecacheParticleSystem( "blood_impact_green_01" );

+	PrecacheParticleSystem( "blood_impact_yellow_01" );

+

+	CBaseEntity::PrecacheModel ("effects/bubble.vmt");//bubble trails

+

+	CBaseEntity::PrecacheModel("models/weapons/w_bullet.mdl");

+#endif

+

+	CBaseEntity::PrecacheScriptSound( "BaseCombatWeapon.WeaponDrop" );

+	CBaseEntity::PrecacheScriptSound( "BaseCombatWeapon.WeaponMaterialize" );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Transmit weapon data

+//-----------------------------------------------------------------------------

+int CBaseCombatWeapon::UpdateTransmitState( void)

+{

+	// If the weapon is being carried by a CBaseCombatCharacter, let the combat character do the logic

+	// about whether or not to transmit it.

+	if ( GetOwner() )

+	{	

+		return SetTransmitState( FL_EDICT_PVSCHECK );

+	}

+	else

+	{

+		// If it's just lying around, then use CBaseEntity's visibility test to see if it should be sent.

+		return BaseClass::UpdateTransmitState();

+	}

+}

+

+

+void CBaseCombatWeapon::Operator_FrameUpdate( CBaseCombatCharacter *pOperator )

+{

+	StudioFrameAdvance( ); // animate

+

+	if ( IsSequenceFinished() )

+	{

+		if ( SequenceLoops() )

+		{

+			// animation does loop, which means we're playing subtle idle. Might need to fidget.

+			int iSequence = SelectWeightedSequence( GetActivity() );

+			if ( iSequence != ACTIVITY_NOT_AVAILABLE )

+			{

+				ResetSequence( iSequence );	// Set to new anim (if it's there)

+			}

+		}

+#if 0

+		else

+		{

+			// animation that just ended doesn't loop! That means we just finished a fidget

+			// and should return to our heaviest weighted idle (the subtle one)

+			SelectHeaviestSequence( GetActivity() );

+		}

+#endif

+	}

+

+	// Animation events are passed back to the weapon's owner/operator

+	DispatchAnimEvents( pOperator );

+

+	// Update and dispatch the viewmodel events

+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );

+

+	if ( pOwner == NULL )

+		return;

+

+	CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex );

+	

+	if ( vm != NULL )

+	{

+		vm->StudioFrameAdvance();

+		vm->DispatchAnimEvents( this );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+// Input  : *pEvent - 

+//			*pOperator - 

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator )

+{

+	if ( (pEvent->type & AE_TYPE_NEWEVENTSYSTEM) && (pEvent->type & AE_TYPE_SERVER) )

+	{

+		if ( pEvent->event == AE_NPC_WEAPON_FIRE )

+		{

+			bool bSecondary = (atoi( pEvent->options ) != 0);

+			Operator_ForceNPCFire( pOperator, bSecondary );

+			return;

+		}

+		else if ( pEvent->event == AE_WPN_PLAYWPNSOUND )

+		{

+			int iSnd = GetWeaponSoundFromString(pEvent->options);

+			if ( iSnd != -1 )

+			{

+				WeaponSound( (WeaponSound_t)iSnd );

+			}

+		}

+	}

+

+	DevWarning( 2, "Unhandled animation event %d from %s --> %s\n", pEvent->event, pOperator->GetClassname(), GetClassname() );

+}

+

+// NOTE: This should never be called when a character is operating the weapon.  Animation events should be

+// routed through the character, and then back into CharacterAnimEvent() 

+void CBaseCombatWeapon::HandleAnimEvent( animevent_t *pEvent )

+{

+	//If the player is receiving this message, pass it through

+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );

+

+	if ( pOwner != NULL )

+	{

+		Operator_HandleAnimEvent( pEvent, pOwner );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Make the weapon visible and tangible

+//-----------------------------------------------------------------------------

+CBaseEntity* CBaseCombatWeapon::Respawn( void )

+{

+	// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code

+	// will decide when to make the weapon visible and touchable.

+	CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetLocalAngles(), GetOwnerEntity() );

+

+	if ( pNewWeapon )

+	{

+		pNewWeapon->AddEffects( EF_NODRAW );// invisible for now

+		pNewWeapon->SetTouch( NULL );// no touch

+		pNewWeapon->SetThink( &CBaseCombatWeapon::AttemptToMaterialize );

+

+		UTIL_DropToFloor( this, MASK_SOLID );

+

+		// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,

+		// but when it should respawn is based on conditions belonging to the weapon that was taken.

+		pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );

+	}

+	else

+	{

+		Warning("Respawn failed to create %s!\n", GetClassname() );

+	}

+

+	return pNewWeapon;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Weapons ignore other weapons when LOS tracing

+//-----------------------------------------------------------------------------

+class CWeaponLOSFilter : public CTraceFilterSkipTwoEntities

+{

+	DECLARE_CLASS( CWeaponLOSFilter, CTraceFilterSkipTwoEntities );

+public:

+	CWeaponLOSFilter( IHandleEntity *pHandleEntity, IHandleEntity *pHandleEntity2, int collisionGroup ) :

+	  CTraceFilterSkipTwoEntities( pHandleEntity, pHandleEntity2, collisionGroup ), m_pVehicle( NULL )

+	{

+		// If the tracing entity is in a vehicle, then ignore it

+		if ( pHandleEntity != NULL )

+		{

+			CBaseCombatCharacter *pBCC = ((CBaseEntity *)pHandleEntity)->MyCombatCharacterPointer();

+			if ( pBCC != NULL )

+			{

+				m_pVehicle = pBCC->GetVehicleEntity();

+			}

+		}

+	}

+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )

+	{

+		CBaseEntity *pEntity = (CBaseEntity *)pServerEntity;

+

+		if ( pEntity->GetCollisionGroup() == COLLISION_GROUP_WEAPON )

+			return false;

+

+		// Don't collide with the tracing entity's vehicle (if it exists)

+		if ( pServerEntity == m_pVehicle )

+			return false;

+

+		if ( pEntity->GetHealth() > 0 )

+		{

+			CBreakable *pBreakable = dynamic_cast<CBreakable *>(pEntity);

+			if ( pBreakable  && pBreakable->IsBreakable() && pBreakable->GetMaterialType() == matGlass)

+			{

+				return false;

+			}

+		}

+

+		return BaseClass::ShouldHitEntity( pServerEntity, contentsMask );

+	}

+

+private:

+	CBaseEntity *m_pVehicle;

+};

+

+//-----------------------------------------------------------------------------

+// Purpose: Check the weapon LOS for an owner at an arbitrary position

+//			If bSetConditions is true, LOS related conditions will also be set

+//-----------------------------------------------------------------------------

+bool CBaseCombatWeapon::WeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions )

+{

+	// --------------------

+	// Check for occlusion

+	// --------------------

+	CAI_BaseNPC* npcOwner = m_hOwner.Get()->MyNPCPointer();

+

+	// Find its relative shoot position

+	Vector vecRelativeShootPosition;

+	VectorSubtract( npcOwner->Weapon_ShootPosition(), npcOwner->GetAbsOrigin(), vecRelativeShootPosition );

+	Vector barrelPos = ownerPos + vecRelativeShootPosition;

+

+	// FIXME: If we're in a vehicle, we need some sort of way to handle shooting out of them

+

+	// Use the custom LOS trace filter

+	CWeaponLOSFilter traceFilter( m_hOwner.Get(), npcOwner->GetEnemy(), COLLISION_GROUP_BREAKABLE_GLASS );

+	trace_t tr;

+	UTIL_TraceLine( barrelPos, targetPos, MASK_SHOT, &traceFilter, &tr );

+

+	// See if we completed the trace without interruption

+	if ( tr.fraction == 1.0 )

+	{

+		if ( ai_debug_shoot_positions.GetBool() )

+		{

+			NDebugOverlay::Line( barrelPos, targetPos, 0, 255, 0, false, 1.0 );

+		}

+

+		return true;

+	}

+

+	CBaseEntity	*pHitEnt = tr.m_pEnt;

+

+	CBasePlayer *pEnemyPlayer = ToBasePlayer( npcOwner->GetEnemy() );

+

+	// is player in a vehicle? if so, verify vehicle is target and return if so (so npc shoots at vehicle)

+	if ( pEnemyPlayer && pEnemyPlayer->IsInAVehicle() )

+	{

+		// Ok, player in vehicle, check if vehicle is target we're looking at, fire if it is

+		// Also, check to see if the owner of the entity is the vehicle, in which case it's valid too.

+		// This catches vehicles that use bone followers.

+		CBaseEntity	*pVehicle  = pEnemyPlayer->GetVehicle()->GetVehicleEnt();

+		if ( pHitEnt == pVehicle || pHitEnt->GetOwnerEntity() == pVehicle )

+			return true;

+	}

+

+	// Hitting our enemy is a success case

+	if ( pHitEnt == npcOwner->GetEnemy() )

+	{

+		if ( ai_debug_shoot_positions.GetBool() )

+		{

+			NDebugOverlay::Line( barrelPos, targetPos, 0, 255, 0, false, 1.0 );

+		}

+

+		return true;

+	}

+

+	// If a vehicle is blocking the view, grab its driver and use that as the combat character

+	CBaseCombatCharacter *pBCC;

+	IServerVehicle *pVehicle = pHitEnt->GetServerVehicle();

+	if ( pVehicle )

+	{

+		pBCC = pVehicle->GetPassenger( );

+	}

+	else

+	{

+		pBCC = ToBaseCombatCharacter( pHitEnt );

+	}

+

+	if ( pBCC ) 

+	{

+		if ( npcOwner->IRelationType( pBCC ) == D_HT )

+			return true;

+

+		if ( bSetConditions )

+		{

+			npcOwner->SetCondition( COND_WEAPON_BLOCKED_BY_FRIEND );

+		}

+	}

+	else if ( bSetConditions )

+	{

+		npcOwner->SetCondition( COND_WEAPON_SIGHT_OCCLUDED );

+		npcOwner->SetEnemyOccluder( pHitEnt );

+

+		if( ai_debug_shoot_positions.GetBool() )

+		{

+			NDebugOverlay::Line( tr.startpos, tr.endpos, 255, 0, 0, false, 1.0 );

+		}

+	}

+

+	return false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Base class always returns not bits

+//-----------------------------------------------------------------------------

+int CBaseCombatWeapon::WeaponRangeAttack1Condition( float flDot, float flDist )

+{

+ 	if ( UsesPrimaryAmmo() && !HasPrimaryAmmo() )

+ 	{

+ 		return COND_NO_PRIMARY_AMMO;

+ 	}

+ 	else if ( flDist < m_fMinRange1) 

+ 	{

+ 		return COND_TOO_CLOSE_TO_ATTACK;

+ 	}

+ 	else if (flDist > m_fMaxRange1) 

+ 	{

+ 		return COND_TOO_FAR_TO_ATTACK;

+ 	}

+ 	else if (flDot < 0.5) 	// UNDONE: Why check this here? Isn't the AI checking this already?

+ 	{

+ 		return COND_NOT_FACING_ATTACK;

+ 	}

+

+ 	return COND_CAN_RANGE_ATTACK1;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Base class always returns not bits

+//-----------------------------------------------------------------------------

+int CBaseCombatWeapon::WeaponRangeAttack2Condition( float flDot, float flDist )

+{

+	// currently disabled

+	return COND_NONE;

+

+	if ( m_bReloadsSingly )

+	{

+		if (m_iClip2 <=0)

+		{

+			return COND_NO_SECONDARY_AMMO;

+		}

+		else if ( flDist < m_fMinRange2) 

+		{

+			return COND_TOO_CLOSE_TO_ATTACK;

+		}

+		else if (flDist > m_fMaxRange2) 

+		{

+			return COND_TOO_FAR_TO_ATTACK;

+		}

+		else if (flDot < 0.5) 

+		{

+			return COND_NOT_FACING_ATTACK;

+		}

+		return COND_CAN_RANGE_ATTACK2;

+	}

+

+	return COND_NONE;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Base class always returns not bits

+//-----------------------------------------------------------------------------

+int CBaseCombatWeapon::WeaponMeleeAttack1Condition( float flDot, float flDist )

+{

+	return COND_NONE;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Base class always returns not bits

+//-----------------------------------------------------------------------------

+int CBaseCombatWeapon::WeaponMeleeAttack2Condition( float flDot, float flDist )

+{

+	return COND_NONE;

+}

+

+//====================================================================================

+// WEAPON DROPPING / DESTRUCTION

+//====================================================================================

+void CBaseCombatWeapon::Delete( void )

+{

+	SetTouch( NULL );

+	// FIXME: why doesn't this just remove itself now?

+	SetThink(&CBaseCombatWeapon::SUB_Remove);

+	SetNextThink( gpGlobals->curtime + 0.1f );

+}

+

+void CBaseCombatWeapon::DestroyItem( void )

+{

+	CBaseCombatCharacter *pOwner = m_hOwner.Get();

+

+	if ( pOwner )

+	{

+		// if attached to a player, remove. 

+		pOwner->RemovePlayerItem( this );

+	}

+

+	Kill( );

+}

+

+void CBaseCombatWeapon::Kill( void )

+{

+	SetTouch( NULL );

+	// FIXME: why doesn't this just remove itself now?

+	// FIXME: how is this different than Delete(), and why do they have the same code in them?

+	SetThink(&CBaseCombatWeapon::SUB_Remove);

+	SetNextThink( gpGlobals->curtime + 0.1f );

+}

+

+//====================================================================================

+// FALL TO GROUND

+//====================================================================================

+//-----------------------------------------------------------------------------

+// Purpose: Setup for the fall

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::FallInit( void )

+{

+	SetModel( GetWorldModel() );

+	VPhysicsDestroyObject();

+

+	if ( !VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false ) )

+	{

+		SetMoveType( MOVETYPE_FLYGRAVITY );

+		SetSolid( SOLID_BBOX );

+		AddSolidFlags( FSOLID_TRIGGER );

+	}

+	else

+	{

+#if !defined( CLIENT_DLL )

+		// Constrained start?

+		if ( HasSpawnFlags( SF_WEAPON_START_CONSTRAINED ) )

+		{

+			//Constrain the weapon in place

+			IPhysicsObject *pReferenceObject, *pAttachedObject;

+			

+			pReferenceObject = g_PhysWorldObject;

+			pAttachedObject = VPhysicsGetObject();

+

+			if ( pReferenceObject && pAttachedObject )

+			{

+				constraint_fixedparams_t fixed;

+				fixed.Defaults();

+				fixed.InitWithCurrentObjectState( pReferenceObject, pAttachedObject );

+				

+				fixed.constraint.forceLimit	= lbs2kg( 10000 );

+				fixed.constraint.torqueLimit = lbs2kg( 10000 );

+

+				m_pConstraint = physenv->CreateFixedConstraint( pReferenceObject, pAttachedObject, NULL, fixed );

+

+				m_pConstraint->SetGameData( (void *) this );

+			}

+		}

+#endif //CLIENT_DLL

+	}	

+

+	SetPickupTouch();

+	

+	SetThink( &CBaseCombatWeapon::FallThink );

+

+	SetNextThink( gpGlobals->curtime + 0.1f );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Items that have just spawned run this think to catch them when 

+//			they hit the ground. Once we're sure that the object is grounded, 

+//			we change its solid type to trigger and set it in a large box that 

+//			helps the player get it.

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::FallThink ( void )

+{

+	SetNextThink( gpGlobals->curtime + 0.1f );

+

+	bool shouldMaterialize = false;

+	IPhysicsObject *pPhysics = VPhysicsGetObject();

+	if ( pPhysics )

+	{

+		shouldMaterialize = pPhysics->IsAsleep();

+	}

+	else

+	{

+		shouldMaterialize = (GetFlags() & FL_ONGROUND) ? true : false;

+	}

+

+	if ( shouldMaterialize )

+	{

+		// clatter if we have an owner (i.e., dropped by someone)

+		// don't clatter if the gun is waiting to respawn (if it's waiting, it is invisible!)

+		if ( GetOwnerEntity() )

+		{

+			EmitSound( "BaseCombatWeapon.WeaponDrop" );

+		}

+		Materialize(); 

+	}

+}

+

+//====================================================================================

+// WEAPON SPAWNING

+//====================================================================================

+//-----------------------------------------------------------------------------

+// Purpose: Make a weapon visible and tangible

+//-----------------------------------------------------------------------------// 

+void CBaseCombatWeapon::Materialize( void )

+{

+	if ( IsEffectActive( EF_NODRAW ) )

+	{

+		// changing from invisible state to visible.

+#ifdef HL2MP

+		EmitSound( "AlyxEmp.Charge" );

+#else

+		EmitSound( "BaseCombatWeapon.WeaponMaterialize" );

+#endif

+		

+		RemoveEffects( EF_NODRAW );

+		DoMuzzleFlash();

+	}

+#ifdef HL2MP

+	if ( HasSpawnFlags( SF_NORESPAWN ) == false )

+	{

+		VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false );

+		SetMoveType( MOVETYPE_VPHYSICS );

+

+		HL2MPRules()->AddLevelDesignerPlacedObject( this );

+	}

+#else

+	SetSolid( SOLID_BBOX );

+	AddSolidFlags( FSOLID_TRIGGER );

+#endif

+

+	SetPickupTouch();

+

+	SetThink (NULL);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: See if the game rules will let this weapon respawn

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::AttemptToMaterialize( void )

+{

+	float time = g_pGameRules->FlWeaponTryRespawn( this );

+

+	if ( time == 0 )

+	{

+		Materialize();

+		return;

+	}

+

+	SetNextThink( gpGlobals->curtime + time );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Weapon has been picked up, should it respawn?

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::CheckRespawn( void )

+{

+	switch ( g_pGameRules->WeaponShouldRespawn( this ) )

+	{

+	case GR_WEAPON_RESPAWN_YES:

+		Respawn();

+		break;

+	case GR_WEAPON_RESPAWN_NO:

+		return;

+		break;

+	}

+}

+

+class CWeaponList : public CAutoGameSystem

+{

+public:

+	CWeaponList( char const *name ) : CAutoGameSystem( name )

+	{

+	}

+

+

+	virtual void LevelShutdownPostEntity()  

+	{ 

+		m_list.Purge();

+	}

+

+	void AddWeapon( CBaseCombatWeapon *pWeapon )

+	{

+		m_list.AddToTail( pWeapon );

+	}

+

+	void RemoveWeapon( CBaseCombatWeapon *pWeapon )

+	{

+		m_list.FindAndRemove( pWeapon );

+	}

+	CUtlLinkedList< CBaseCombatWeapon * > m_list;

+};

+

+CWeaponList g_WeaponList( "CWeaponList" );

+

+void OnBaseCombatWeaponCreated( CBaseCombatWeapon *pWeapon )

+{

+	g_WeaponList.AddWeapon( pWeapon );

+}

+

+void OnBaseCombatWeaponDestroyed( CBaseCombatWeapon *pWeapon )

+{

+	g_WeaponList.RemoveWeapon( pWeapon );

+}

+

+int CBaseCombatWeapon::GetAvailableWeaponsInBox( CBaseCombatWeapon **pList, int listMax, const Vector &mins, const Vector &maxs )

+{

+	// linear search all weapons

+	int count = 0;

+	int index = g_WeaponList.m_list.Head();

+	while ( index != g_WeaponList.m_list.InvalidIndex() )

+	{

+		CBaseCombatWeapon *pWeapon = g_WeaponList.m_list[index];

+		// skip any held weapon

+		if ( !pWeapon->GetOwner() )

+		{

+			// restrict to mins/maxs

+			if ( IsPointInBox( pWeapon->GetAbsOrigin(), mins, maxs ) )

+			{

+				if ( count < listMax )

+				{

+					pList[count] = pWeapon;

+					count++;

+				}

+			}

+		}

+		index = g_WeaponList.m_list.Next( index );

+	}

+

+	return count;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+int	CBaseCombatWeapon::ObjectCaps( void )

+{ 

+	int caps = BaseClass::ObjectCaps();

+	if ( !IsFollowingEntity() && !HasSpawnFlags(SF_WEAPON_NO_PLAYER_PICKUP) )

+	{

+		caps |= FCAP_IMPULSE_USE;

+	}

+

+	return caps;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CBaseCombatWeapon::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )

+{

+	CBasePlayer *pPlayer = ToBasePlayer( pActivator );

+	

+	if ( pPlayer )

+	{

+		m_OnPlayerUse.FireOutput( pActivator, pCaller );

+

+		//

+		// Bump the weapon to try equipping it before picking it up physically. This is

+		// important in a few spots in the game where the player could potentially +use pickup

+		// and then THROW AWAY a vital weapon, rendering them unable to continue the game.

+		//

+		if ( pPlayer->BumpWeapon( this ) )

+		{

+			OnPickedUp( pPlayer );

+		}

+		else

+		{

+			pPlayer->PickupObject( this );

+		}

+	}

+}

+