First version of the SOurce SDK 2013

1 files changed, 2379 insertions, 0 deletions

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

+//

+// Purpose: Implements a grab bag of visual effects entities.

+//

+// $NoKeywords: $

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

+

+#include "cbase.h"

+#include "effects.h"

+#include "gib.h"

+#include "beam_shared.h"

+#include "decals.h"

+#include "func_break.h"

+#include "EntityFlame.h"

+#include "entitylist.h"

+#include "basecombatweapon.h"

+#include "model_types.h"

+#include "player.h"

+#include "physics.h"

+#include "baseparticleentity.h"

+#include "ndebugoverlay.h"

+#include "IEffects.h"

+#include "vstdlib/random.h"

+#include "env_wind_shared.h"

+#include "filesystem.h"

+#include "engine/IEngineSound.h"

+#include "fire.h"

+#include "te_effect_dispatch.h"

+#include "Sprite.h"

+#include "precipitation_shared.h"

+#include "shot_manipulator.h"

+

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

+#include "tier0/memdbgon.h"

+

+#define SF_FUNNEL_REVERSE			1 // funnel effect repels particles instead of attracting them.

+

+#define	SF_GIBSHOOTER_REPEATABLE	(1<<0)	// allows a gibshooter to be refired

+#define	SF_SHOOTER_FLAMING			(1<<1)	// gib is on fire

+#define SF_SHOOTER_STRICT_REMOVE	(1<<2)	// remove this gib even if it is in the player's view

+

+// UNDONE: This should be client-side and not use TempEnts

+class CBubbling : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CBubbling, CBaseEntity );

+

+	virtual  void	Spawn( void );

+	virtual void	Precache( void );

+

+	void	FizzThink( void );

+

+	// Input handlers.

+	void	InputActivate( inputdata_t &inputdata );

+	void	InputDeactivate( inputdata_t &inputdata );

+	void	InputToggle( inputdata_t &inputdata );

+

+	void	InputSetCurrent( inputdata_t &inputdata );

+	void	InputSetDensity( inputdata_t &inputdata );

+	void	InputSetFrequency( inputdata_t &inputdata );

+

+	DECLARE_DATADESC();

+

+private:

+

+	void TurnOn();

+	void TurnOff();

+	void Toggle();

+

+	int		m_density;

+	int		m_frequency;

+	int		m_bubbleModel;

+	int		m_state;

+};

+

+LINK_ENTITY_TO_CLASS( env_bubbles, CBubbling );

+

+BEGIN_DATADESC( CBubbling )

+

+	DEFINE_KEYFIELD( m_flSpeed, FIELD_FLOAT, "current" ),

+	DEFINE_KEYFIELD( m_density, FIELD_INTEGER, "density" ),

+	DEFINE_KEYFIELD( m_frequency, FIELD_INTEGER, "frequency" ),

+

+	DEFINE_FIELD( m_state, FIELD_INTEGER ),

+	// Let spawn restore this!

+	//	DEFINE_FIELD( m_bubbleModel, FIELD_INTEGER ),

+

+	// Function Pointers

+	DEFINE_FUNCTION( FizzThink ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ),

+	DEFINE_INPUTFUNC( FIELD_VOID, "Deactivate", InputDeactivate ),

+	DEFINE_INPUTFUNC( FIELD_VOID, "Toggle", InputToggle ),

+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetCurrent", InputSetCurrent ),

+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetDensity", InputSetDensity ),

+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetFrequency", InputSetFrequency ),

+

+END_DATADESC()

+

+

+

+#define SF_BUBBLES_STARTOFF		0x0001

+

+void CBubbling::Spawn( void )

+{

+	Precache( );

+	SetModel( STRING( GetModelName() ) );		// Set size

+

+	// Make it invisible to client

+	SetRenderColorA( 0 );

+

+	SetSolid( SOLID_NONE );						// Remove model & collisions

+

+	if ( !HasSpawnFlags(SF_BUBBLES_STARTOFF) )

+	{

+		SetThink( &CBubbling::FizzThink );

+		SetNextThink( gpGlobals->curtime + 2.0 );

+		m_state = 1;

+	}

+	else

+	{

+		m_state = 0;

+	}

+}

+

+void CBubbling::Precache( void )

+{

+	m_bubbleModel = PrecacheModel("sprites/bubble.vmt");			// Precache bubble sprite

+}

+

+

+void CBubbling::Toggle()

+{

+	if (!m_state)

+	{

+		TurnOn();

+	}

+	else

+	{

+		TurnOff();

+	}

+}

+

+

+void CBubbling::TurnOn()

+{

+	m_state = 1;

+	SetThink( &CBubbling::FizzThink );

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

+}

+

+void CBubbling::TurnOff()

+{

+	m_state = 0;

+	SetThink( NULL );

+	SetNextThink( TICK_NEVER_THINK );

+}

+

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

+// Purpose:

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

+void CBubbling::InputActivate( inputdata_t &inputdata )

+{

+	TurnOn();

+}

+

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

+// Purpose:

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

+void CBubbling::InputDeactivate( inputdata_t &inputdata )

+{

+	TurnOff();

+}

+

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

+// Purpose:

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

+void CBubbling::InputToggle( inputdata_t &inputdata )

+{

+	Toggle();

+}

+

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

+// Purpose:

+// Input  : &inputdata -

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

+void CBubbling::InputSetCurrent( inputdata_t &inputdata )

+{

+	m_flSpeed = (float)inputdata.value.Int();

+}

+

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

+// Purpose:

+// Input  : &inputdata -

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

+void CBubbling::InputSetDensity( inputdata_t &inputdata )

+{

+	m_density = inputdata.value.Int();

+}

+

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

+// Purpose:

+// Input  : &inputdata -

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

+void CBubbling::InputSetFrequency( inputdata_t &inputdata )

+{

+	m_frequency = inputdata.value.Int();

+

+	// Reset think time

+	if ( m_state )

+	{

+		if ( m_frequency > 19 )

+		{

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

+		}

+		else

+		{

+			SetNextThink( gpGlobals->curtime + 2.5 - (0.1 * m_frequency) );

+		}

+	}

+}

+

+void CBubbling::FizzThink( void )

+{

+	Vector center = WorldSpaceCenter();

+	CPASFilter filter( center );

+	te->Fizz( filter, 0.0, this, m_bubbleModel, m_density, (int)m_flSpeed );

+

+	if ( m_frequency > 19 )

+	{

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

+	}

+	else

+	{

+		SetNextThink( gpGlobals->curtime + 2.5 - (0.1 * m_frequency) );

+	}

+}

+

+

+// ENV_TRACER

+// Fakes a tracer

+class CEnvTracer : public CPointEntity

+{

+public:

+	DECLARE_CLASS( CEnvTracer, CPointEntity );

+

+	void Spawn( void );

+	void TracerThink( void );

+	void Activate( void );

+

+	DECLARE_DATADESC();

+

+	Vector m_vecEnd;

+	float  m_flDelay;

+};

+

+LINK_ENTITY_TO_CLASS( env_tracer, CEnvTracer );

+

+BEGIN_DATADESC( CEnvTracer )

+

+	DEFINE_KEYFIELD( m_flDelay, FIELD_FLOAT, "delay" ),

+

+	DEFINE_FIELD( m_vecEnd, FIELD_POSITION_VECTOR ),

+

+	// Function Pointers

+	DEFINE_FUNCTION( TracerThink ),

+

+END_DATADESC()

+

+

+

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

+// Purpose: Called after keyvalues are parsed.

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

+void CEnvTracer::Spawn( void )

+{

+	SetSolid( SOLID_NONE );

+	SetMoveType( MOVETYPE_NONE );

+

+	if (!m_flDelay)

+		m_flDelay = 1;

+}

+

+

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

+// Purpose: Called after all the entities have been loaded.

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

+void CEnvTracer::Activate( void )

+{

+	BaseClass::Activate();

+

+	CBaseEntity *pEnd = gEntList.FindEntityByName( NULL, m_target );

+	if (pEnd != NULL)

+	{

+		m_vecEnd = pEnd->GetLocalOrigin();

+		SetThink( &CEnvTracer::TracerThink );

+		SetNextThink( gpGlobals->curtime + m_flDelay );

+	}

+	else

+	{

+		Msg( "env_tracer: unknown entity \"%s\"\n", STRING(m_target) );

+	}

+}

+

+// Think

+void CEnvTracer::TracerThink( void )

+{

+	UTIL_Tracer( GetAbsOrigin(), m_vecEnd );

+

+	SetNextThink( gpGlobals->curtime + m_flDelay );

+}

+

+

+//#################################################################################

+//  >> CGibShooter

+//#################################################################################

+enum GibSimulation_t

+{

+	GIB_SIMULATE_POINT,

+	GIB_SIMULATE_PHYSICS,

+	GIB_SIMULATE_RAGDOLL,

+};

+

+class CGibShooter : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CGibShooter, CBaseEntity );

+

+	void Spawn( void );

+	void Precache( void );

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

+

+	virtual CGib *CreateGib( void );

+

+protected:

+	// Purpose:

+	CBaseEntity *SpawnGib( const Vector &vecShootDir, float flSpeed );

+

+	DECLARE_DATADESC();

+private:

+	void InitPointGib( CGib *pGib, const Vector &vecShootDir, float flSpeed );

+	void ShootThink( void );

+

+protected:

+	int		m_iGibs;

+	int		m_iGibCapacity;

+	int		m_iGibMaterial;

+	int		m_iGibModelIndex;

+	float	m_flGibVelocity;

+	QAngle	m_angGibRotation;

+	float	m_flGibAngVelocity;

+	float	m_flVariance;

+	float	m_flGibLife;

+	int		m_nSimulationType;

+	int		m_nMaxGibModelFrame;

+	float	m_flDelay;

+

+	bool	m_bNoGibShadows;

+

+	bool	m_bIsSprite;

+	string_t m_iszLightingOrigin;

+

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

+	//	Inputs

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

+	void InputShoot( inputdata_t &inputdata );

+};

+

+BEGIN_DATADESC( CGibShooter )

+

+	DEFINE_KEYFIELD( m_iGibs, FIELD_INTEGER, "m_iGibs" ),

+	DEFINE_KEYFIELD( m_flGibVelocity, FIELD_FLOAT, "m_flVelocity" ),

+	DEFINE_KEYFIELD( m_flVariance, FIELD_FLOAT, "m_flVariance" ),

+	DEFINE_KEYFIELD( m_flGibLife, FIELD_FLOAT, "m_flGibLife" ),

+	DEFINE_KEYFIELD( m_nSimulationType, FIELD_INTEGER, "Simulation" ),

+	DEFINE_KEYFIELD( m_flDelay, FIELD_FLOAT, "delay" ),

+	DEFINE_KEYFIELD( m_angGibRotation, FIELD_VECTOR, "gibangles" ),

+	DEFINE_KEYFIELD( m_flGibAngVelocity, FIELD_FLOAT, "gibanglevelocity"),

+	DEFINE_FIELD( m_bIsSprite, FIELD_BOOLEAN ),

+

+	DEFINE_FIELD( m_iGibCapacity, FIELD_INTEGER ),

+	DEFINE_FIELD( m_iGibMaterial, FIELD_INTEGER ),

+	DEFINE_FIELD( m_iGibModelIndex, FIELD_INTEGER ),

+	DEFINE_FIELD( m_nMaxGibModelFrame, FIELD_INTEGER ),

+

+	DEFINE_KEYFIELD( m_iszLightingOrigin, FIELD_STRING, "LightingOrigin" ),

+	DEFINE_KEYFIELD( m_bNoGibShadows, FIELD_BOOLEAN, "nogibshadows" ),

+

+	// Inputs

+	DEFINE_INPUTFUNC( FIELD_VOID,	"Shoot", InputShoot ),

+

+	// Function Pointers

+	DEFINE_FUNCTION( ShootThink ),

+

+END_DATADESC()

+

+LINK_ENTITY_TO_CLASS( gibshooter, CGibShooter );

+

+

+void CGibShooter::Precache ( void )

+{

+	if ( g_Language.GetInt() == LANGUAGE_GERMAN )

+	{

+		m_iGibModelIndex = PrecacheModel ("models/germanygibs.mdl");

+	}

+	else

+	{

+		m_iGibModelIndex = PrecacheModel ("models/gibs/hgibs.mdl");

+	}

+}

+

+

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

+{

+	SetThink( &CGibShooter::ShootThink );

+	SetNextThink( gpGlobals->curtime );

+}

+

+

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

+// Purpose: Input handler for shooting gibs.

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

+void CGibShooter::InputShoot( inputdata_t &inputdata )

+{

+	SetThink( &CGibShooter::ShootThink );

+	SetNextThink( gpGlobals->curtime );

+}

+

+

+void CGibShooter::Spawn( void )

+{

+	Precache();

+

+	SetSolid( SOLID_NONE );

+	AddEffects( EF_NODRAW );

+

+	if ( m_flDelay < 0 )

+	{

+		m_flDelay = 0.0;

+	}

+

+	if ( m_flGibLife == 0 )

+	{

+		m_flGibLife = 25;

+	}

+

+	m_iGibCapacity = m_iGibs;

+

+	m_nMaxGibModelFrame = modelinfo->GetModelFrameCount( modelinfo->GetModel( m_iGibModelIndex ) );

+}

+

+CGib *CGibShooter::CreateGib ( void )

+{

+	ConVarRef violence_hgibs( "violence_hgibs" );

+	if ( violence_hgibs.IsValid() && !violence_hgibs.GetInt() )

+		return NULL;

+

+	CGib *pGib = CREATE_ENTITY( CGib, "gib" );

+	pGib->Spawn( "models/gibs/hgibs.mdl" );

+	pGib->SetBloodColor( BLOOD_COLOR_RED );

+

+	if ( m_nMaxGibModelFrame <= 1 )

+	{

+		DevWarning( 2, "GibShooter Body is <= 1!\n" );

+	}

+

+	pGib->m_nBody = random->RandomInt ( 1, m_nMaxGibModelFrame - 1 );// avoid throwing random amounts of the 0th gib. (skull).

+

+	if ( m_iszLightingOrigin != NULL_STRING )

+	{

+		// Make the gibs use the lighting origin

+		pGib->SetLightingOrigin( m_iszLightingOrigin );

+	}

+

+	return pGib;

+}

+

+

+void CGibShooter::InitPointGib( CGib *pGib, const Vector &vecShootDir, float flSpeed )

+{

+	if ( pGib )

+	{

+		pGib->SetLocalOrigin( GetAbsOrigin() );

+		pGib->SetAbsVelocity( vecShootDir * flSpeed );

+

+		QAngle angVel( random->RandomFloat ( 100, 200 ), random->RandomFloat ( 100, 300 ), 0 );

+		pGib->SetLocalAngularVelocity( angVel );

+

+		float thinkTime = ( pGib->GetNextThink() - gpGlobals->curtime );

+

+		pGib->m_lifeTime = (m_flGibLife * random->RandomFloat( 0.95, 1.05 ));	// +/- 5%

+

+		// HL1 gibs always die after a certain time, other games have to opt-in

+#ifndef HL1_DLL

+		if( HasSpawnFlags( SF_SHOOTER_STRICT_REMOVE ) )

+#endif

+		{

+			pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );

+			pGib->SetThink ( &CGib::DieThink );

+		}

+

+		if ( pGib->m_lifeTime < thinkTime )

+		{

+			pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );

+			pGib->m_lifeTime = 0;

+		}

+

+		if ( m_bIsSprite == true )

+		{

+			pGib->SetSprite( CSprite::SpriteCreate( STRING( GetModelName() ), pGib->GetAbsOrigin(), false ) );

+

+			CSprite *pSprite = (CSprite*)pGib->GetSprite();

+

+			if ( pSprite )

+			{

+				pSprite->SetAttachment( pGib, 0 );

+				pSprite->SetOwnerEntity( pGib );

+

+				pSprite->SetScale( 1 );

+				pSprite->SetTransparency( m_nRenderMode, m_clrRender->r, m_clrRender->g, m_clrRender->b, m_clrRender->a, m_nRenderFX );

+				pSprite->AnimateForTime( 5, m_flGibLife + 1 ); //This framerate is totally wrong

+			}

+		}

+	}

+}

+

+

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

+// Purpose:

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

+CBaseEntity *CGibShooter::SpawnGib( const Vector &vecShootDir, float flSpeed )

+{

+	switch (m_nSimulationType)

+	{

+		case GIB_SIMULATE_RAGDOLL:

+		{

+			// UNDONE: Assume a mass of 200 for now

+			Vector force = vecShootDir * flSpeed * 200;

+			return CreateRagGib( STRING( GetModelName() ), GetAbsOrigin(), GetAbsAngles(), force, m_flGibLife );

+		}

+

+		case GIB_SIMULATE_PHYSICS:

+		{

+			CGib *pGib = CreateGib();

+

+			if ( pGib )

+			{

+				pGib->SetAbsOrigin( GetAbsOrigin() );

+				pGib->SetAbsAngles( m_angGibRotation );

+

+				pGib->m_lifeTime = (m_flGibLife * random->RandomFloat( 0.95, 1.05 ));	// +/- 5%

+

+				pGib->SetCollisionGroup( COLLISION_GROUP_DEBRIS );

+				IPhysicsObject *pPhysicsObject = pGib->VPhysicsInitNormal( SOLID_VPHYSICS, pGib->GetSolidFlags(), false );

+				pGib->SetMoveType( MOVETYPE_VPHYSICS );

+

+				if ( pPhysicsObject )

+				{

+					// Set gib velocity

+					Vector vVel		= vecShootDir * flSpeed;

+					pPhysicsObject->AddVelocity(&vVel, NULL);

+

+					AngularImpulse torque;

+					torque.x = m_flGibAngVelocity * random->RandomFloat( 0.1f, 1.0f );

+					torque.y = m_flGibAngVelocity * random->RandomFloat( 0.1f, 1.0f );

+					torque.z = 0.0f;

+					torque *= pPhysicsObject->GetMass();

+

+					pPhysicsObject->ApplyTorqueCenter( torque );

+

+#ifndef HL1_DLL

+					if( HasSpawnFlags( SF_SHOOTER_STRICT_REMOVE ) )

+#endif

+					{

+						pGib->m_bForceRemove = true;

+						pGib->SetNextThink( gpGlobals->curtime + pGib->m_lifeTime );

+						pGib->SetThink ( &CGib::DieThink );

+					}

+

+				}

+				else

+				{

+					InitPointGib( pGib, vecShootDir, flSpeed );

+				}

+			}

+			return pGib;

+		}

+

+		case GIB_SIMULATE_POINT:

+		{

+			CGib *pGib = CreateGib();

+

+			if ( pGib )

+			{

+				pGib->SetAbsAngles( m_angGibRotation );

+

+				InitPointGib( pGib, vecShootDir, flSpeed );

+				return pGib;

+			}

+		}

+	}

+

+	return NULL;

+}

+

+

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

+// Purpose:

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

+void CGibShooter::ShootThink ( void )

+{

+	SetNextThink( gpGlobals->curtime + m_flDelay );

+

+	Vector vecShootDir, vForward,vRight,vUp;

+	AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );

+	vecShootDir = vForward;

+	vecShootDir = vecShootDir + vRight * random->RandomFloat( -1, 1) * m_flVariance;

+	vecShootDir = vecShootDir + vForward * random->RandomFloat( -1, 1) * m_flVariance;

+	vecShootDir = vecShootDir + vUp * random->RandomFloat( -1, 1) * m_flVariance;

+

+	VectorNormalize( vecShootDir );

+

+	SpawnGib( vecShootDir, m_flGibVelocity );

+

+	if ( --m_iGibs <= 0 )

+	{

+		if ( HasSpawnFlags(SF_GIBSHOOTER_REPEATABLE) )

+		{

+			m_iGibs = m_iGibCapacity;

+			SetThink ( NULL );

+			SetNextThink( gpGlobals->curtime );

+		}

+		else

+		{

+			SetThink ( &CGibShooter::SUB_Remove );

+			SetNextThink( gpGlobals->curtime );

+		}

+	}

+}

+

+class CEnvShooter : public CGibShooter

+{

+public:

+	DECLARE_CLASS( CEnvShooter, CGibShooter );

+

+	CEnvShooter() { m_flGibGravityScale = 1.0f; }

+	void		Precache( void );

+	bool		KeyValue( const char *szKeyName, const char *szValue );

+

+	CGib		*CreateGib( void );

+

+	DECLARE_DATADESC();

+

+public:

+

+	int m_nSkin;

+	float m_flGibScale;

+	float m_flGibGravityScale;

+

+#if HL2_EPISODIC

+	float m_flMassOverride;	// allow designer to force a mass for gibs in some cases

+#endif

+};

+

+BEGIN_DATADESC( CEnvShooter )

+

+	DEFINE_KEYFIELD( m_nSkin, FIELD_INTEGER, "skin" ),

+	DEFINE_KEYFIELD( m_flGibScale, FIELD_FLOAT ,"scale" ),

+	DEFINE_KEYFIELD( m_flGibGravityScale, FIELD_FLOAT, "gibgravityscale" ),

+

+#if HL2_EPISODIC

+	DEFINE_KEYFIELD( m_flMassOverride, FIELD_FLOAT, "massoverride" ),

+#endif

+

+END_DATADESC()

+

+

+LINK_ENTITY_TO_CLASS( env_shooter, CEnvShooter );

+

+bool CEnvShooter::KeyValue( const char *szKeyName, const char *szValue )

+{

+	if (FStrEq(szKeyName, "shootmodel"))

+	{

+		m_bIsSprite = false;

+		SetModelName( AllocPooledString(szValue) );

+

+		//Adrian - not pretty...

+		if ( Q_stristr( szValue, ".vmt" ) )

+			 m_bIsSprite = true;

+	}

+

+	else if (FStrEq(szKeyName, "shootsounds"))

+	{

+		int iNoise = atoi(szValue);

+		switch( iNoise )

+		{

+		case 0:

+			m_iGibMaterial = matGlass;

+			break;

+		case 1:

+			m_iGibMaterial = matWood;

+			break;

+		case 2:

+			m_iGibMaterial = matMetal;

+			break;

+		case 3:

+			m_iGibMaterial = matFlesh;

+			break;

+		case 4:

+			m_iGibMaterial = matRocks;

+			break;

+

+		default:

+		case -1:

+			m_iGibMaterial = matNone;

+			break;

+		}

+	}

+	else

+	{

+		return BaseClass::KeyValue( szKeyName, szValue );

+	}

+

+	return true;

+}

+

+

+void CEnvShooter::Precache ( void )

+{

+	m_iGibModelIndex = PrecacheModel( STRING( GetModelName() ) );

+}

+

+

+CGib *CEnvShooter::CreateGib ( void )

+{

+	CGib *pGib = CREATE_ENTITY( CGib, "gib" );

+

+	if ( m_bIsSprite == true )

+	{

+		//HACK HACK

+		pGib->Spawn( "" );

+	}

+	else

+	{

+		pGib->Spawn( STRING( GetModelName() ) );

+	}

+

+	int bodyPart = 0;

+

+	if ( m_nMaxGibModelFrame > 1 )

+	{

+		bodyPart = random->RandomInt( 0, m_nMaxGibModelFrame-1 );

+	}

+

+	pGib->m_nBody = bodyPart;

+	pGib->SetBloodColor( DONT_BLEED );

+	pGib->m_material = m_iGibMaterial;

+

+	pGib->m_nRenderMode = m_nRenderMode;

+	pGib->m_clrRender = m_clrRender;

+	pGib->m_nRenderFX = m_nRenderFX;

+	pGib->m_nSkin = m_nSkin;

+	pGib->m_lifeTime = gpGlobals->curtime + m_flGibLife;

+

+	pGib->SetGravity( m_flGibGravityScale );

+

+	// Spawn a flaming gib

+	if ( HasSpawnFlags( SF_SHOOTER_FLAMING ) )

+	{

+		// Tag an entity flame along with us

+		CEntityFlame *pFlame = CEntityFlame::Create( pGib, false );

+		if ( pFlame != NULL )

+		{

+			pFlame->SetLifetime( pGib->m_lifeTime );

+			pGib->SetFlame( pFlame );

+		}

+	}

+

+	if ( m_iszLightingOrigin != NULL_STRING )

+	{

+		// Make the gibs use the lighting origin

+		pGib->SetLightingOrigin( m_iszLightingOrigin );

+	}

+

+	if( m_bNoGibShadows )

+	{

+		pGib->AddEffects( EF_NOSHADOW );

+	}

+

+#if HL2_EPISODIC

+	// if a mass override is set, apply it to the gib

+	if (m_flMassOverride != 0)

+	{

+		IPhysicsObject *pPhys = pGib->VPhysicsGetObject();

+		if (pPhys)

+		{

+			pPhys->SetMass( m_flMassOverride );

+		}

+	}

+#endif

+

+	return pGib;

+}

+

+

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

+// An entity that shoots out junk when hit by a rotor wash

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

+class CRotorWashShooter : public CEnvShooter, public IRotorWashShooter

+{

+public:

+	DECLARE_CLASS( CRotorWashShooter, CEnvShooter );

+	DECLARE_DATADESC();

+

+	virtual void Spawn();

+

+public:

+	// Inherited from IRotorWashShooter

+	virtual CBaseEntity *DoWashPush( float flTimeSincePushStarted, const Vector &vecForce );

+

+private:

+	// Amount of time we need to spend under the rotor before we shoot

+	float m_flTimeUnderRotor;

+	float m_flTimeUnderRotorVariance;

+

+	// Last time we were hit with a wash...

+	float m_flLastWashStartTime;

+	float m_flNextGibTime;

+};

+

+

+LINK_ENTITY_TO_CLASS( env_rotorshooter, CRotorWashShooter );

+

+

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

+// Save/load

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

+BEGIN_DATADESC( CRotorWashShooter )

+

+	DEFINE_KEYFIELD( m_flTimeUnderRotor,	FIELD_FLOAT ,"rotortime" ),

+	DEFINE_KEYFIELD( m_flTimeUnderRotorVariance,	FIELD_FLOAT ,"rotortimevariance" ),

+	DEFINE_FIELD( m_flLastWashStartTime,	FIELD_TIME ),

+	DEFINE_FIELD( m_flNextGibTime, FIELD_TIME ),

+

+END_DATADESC()

+

+

+

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

+// Gets at the interface if the entity supports it

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

+IRotorWashShooter *GetRotorWashShooter( CBaseEntity *pEntity )

+{

+	CRotorWashShooter *pShooter = dynamic_cast<CRotorWashShooter*>(pEntity);

+	return pShooter;

+}

+

+

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

+// Inherited from IRotorWashShooter

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

+void CRotorWashShooter::Spawn()

+{

+	BaseClass::Spawn();

+	m_flLastWashStartTime = -1;

+}

+

+

+

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

+// Inherited from IRotorWashShooter

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

+CBaseEntity *CRotorWashShooter::DoWashPush( float flWashStartTime, const Vector &vecForce )

+{

+	if ( flWashStartTime == m_flLastWashStartTime )

+	{

+		if ( m_flNextGibTime > gpGlobals->curtime )

+			return NULL;

+	}

+

+	m_flLastWashStartTime = flWashStartTime;

+	m_flNextGibTime	= gpGlobals->curtime + m_flTimeUnderRotor + random->RandomFloat( -1, 1) * m_flTimeUnderRotorVariance;

+	if ( m_flNextGibTime <= gpGlobals->curtime )

+	{

+		m_flNextGibTime = gpGlobals->curtime + 0.01f;

+	}

+

+	// Set the velocity to be what the force would cause it to accelerate to

+	// after one tick

+	Vector vecShootDir = vecForce;

+	VectorNormalize( vecShootDir );

+

+	vecShootDir.x += random->RandomFloat( -1, 1 ) * m_flVariance;

+	vecShootDir.y += random->RandomFloat( -1, 1 ) * m_flVariance;

+	vecShootDir.z += random->RandomFloat( -1, 1 ) * m_flVariance;

+

+	VectorNormalize( vecShootDir );

+

+	CBaseEntity *pGib = SpawnGib( vecShootDir, m_flGibVelocity /*flLength*/ );

+

+	if ( --m_iGibs <= 0 )

+	{

+		if ( HasSpawnFlags(SF_GIBSHOOTER_REPEATABLE) )

+		{

+			m_iGibs = m_iGibCapacity;

+		}

+		else

+		{

+			SetThink ( &CGibShooter::SUB_Remove );

+			SetNextThink( gpGlobals->curtime );

+		}

+	}

+

+	return pGib;

+}

+

+

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

+// Purpose:

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

+class CTestEffect : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CTestEffect, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

+	// bool	KeyValue( const char *szKeyName, const char *szValue );

+	void Think( void );

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

+

+	int		m_iLoop;

+	int		m_iBeam;

+	CBeam	*m_pBeam[24];

+	float	m_flBeamTime[24];

+	float	m_flStartTime;

+};

+

+

+LINK_ENTITY_TO_CLASS( test_effect, CTestEffect );

+

+void CTestEffect::Spawn( void )

+{

+	Precache( );

+}

+

+void CTestEffect::Precache( void )

+{

+	PrecacheModel( "sprites/lgtning.vmt" );

+}

+

+void CTestEffect::Think( void )

+{

+	int i;

+	float t = (gpGlobals->curtime - m_flStartTime);

+

+	if (m_iBeam < 24)

+	{

+		CBeam *pbeam = CBeam::BeamCreate( "sprites/lgtning.vmt", 10 );

+

+		trace_t	tr;

+

+		Vector vecSrc = GetAbsOrigin();

+		Vector vecDir = Vector( random->RandomFloat( -1.0, 1.0 ), random->RandomFloat( -1.0, 1.0 ),random->RandomFloat( -1.0, 1.0 ) );

+		VectorNormalize( vecDir );

+		UTIL_TraceLine( vecSrc, vecSrc + vecDir * 128, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);

+

+		pbeam->PointsInit( vecSrc, tr.endpos );

+		// pbeam->SetColor( 80, 100, 255 );

+		pbeam->SetColor( 255, 180, 100 );

+		pbeam->SetWidth( 10.0 );

+		pbeam->SetScrollRate( 12 );

+

+		m_flBeamTime[m_iBeam] = gpGlobals->curtime;

+		m_pBeam[m_iBeam] = pbeam;

+		m_iBeam++;

+

+#if 0

+		Vector vecMid = (vecSrc + tr.endpos) * 0.5;

+		CBroadcastRecipientFilter filter;

+		TE_DynamicLight( filter, 0.0,

+			vecMid, 255, 180, 100, 3, 2.0, 0.0 );

+#endif

+	}

+

+	if (t < 3.0)

+	{

+		for (i = 0; i < m_iBeam; i++)

+		{

+			t = (gpGlobals->curtime - m_flBeamTime[i]) / ( 3 + m_flStartTime - m_flBeamTime[i]);

+			m_pBeam[i]->SetBrightness( 255 * t );

+			// m_pBeam[i]->SetScrollRate( 20 * t );

+		}

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

+	}

+	else

+	{

+		for (i = 0; i < m_iBeam; i++)

+		{

+			UTIL_Remove( m_pBeam[i] );

+		}

+		m_flStartTime = gpGlobals->curtime;

+		m_iBeam = 0;

+		SetNextThink( TICK_NEVER_THINK );

+	}

+}

+

+

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

+{

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

+	m_flStartTime = gpGlobals->curtime;

+}

+

+

+

+// Blood effects

+class CBlood : public CPointEntity

+{

+public:

+	DECLARE_CLASS( CBlood, CPointEntity );

+

+	void	Spawn( void );

+	bool	KeyValue( const char *szKeyName, const char *szValue );

+

+	inline	int		Color( void ) { return m_Color; }

+	inline	float 	BloodAmount( void ) { return m_flAmount; }

+

+	inline	void SetColor( int color ) { m_Color = color; }

+

+	// Input handlers

+	void InputEmitBlood( inputdata_t &inputdata );

+

+	Vector	Direction( void );

+	Vector	BloodPosition( CBaseEntity *pActivator );

+

+	DECLARE_DATADESC();

+

+	Vector m_vecSprayDir;

+	float m_flAmount;

+	int m_Color;

+

+private:

+};

+

+LINK_ENTITY_TO_CLASS( env_blood, CBlood );

+

+BEGIN_DATADESC( CBlood )

+

+	DEFINE_KEYFIELD( m_vecSprayDir, FIELD_VECTOR, "spraydir" ),

+	DEFINE_KEYFIELD( m_flAmount, FIELD_FLOAT, "amount" ),

+	DEFINE_FIELD( m_Color, FIELD_INTEGER ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "EmitBlood", InputEmitBlood ),

+

+END_DATADESC()

+

+

+#define SF_BLOOD_RANDOM		0x0001

+#define SF_BLOOD_STREAM		0x0002

+#define SF_BLOOD_PLAYER		0x0004

+#define SF_BLOOD_DECAL		0x0008

+#define SF_BLOOD_CLOUD		0x0010

+#define SF_BLOOD_DROPS		0x0020

+#define SF_BLOOD_GORE		0x0040

+

+

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

+// Purpose:

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

+void CBlood::Spawn( void )

+{

+	// Convert spraydir from angles to a vector

+	QAngle angSprayDir = QAngle( m_vecSprayDir.x, m_vecSprayDir.y, m_vecSprayDir.z );

+	AngleVectors( angSprayDir, &m_vecSprayDir );

+

+	SetSolid( SOLID_NONE );

+	SetMoveType( MOVETYPE_NONE );

+	SetColor( BLOOD_COLOR_RED );

+}

+

+

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

+// Purpose:

+// Input  : szKeyName -

+//			szValue -

+// Output : Returns true on success, false on failure.

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

+bool CBlood::KeyValue( const char *szKeyName, const char *szValue )

+{

+	if (FStrEq(szKeyName, "color"))

+	{

+		int color = atoi(szValue);

+		switch ( color )

+		{

+			case 1:

+			{

+				SetColor( BLOOD_COLOR_YELLOW );

+				break;

+			}

+		}

+	}

+	else

+	{

+		return BaseClass::KeyValue( szKeyName, szValue );

+	}

+

+	return true;

+}

+

+

+Vector CBlood::Direction( void )

+{

+	if ( HasSpawnFlags( SF_BLOOD_RANDOM ) )

+		return UTIL_RandomBloodVector();

+

+	return m_vecSprayDir;

+}

+

+

+Vector CBlood::BloodPosition( CBaseEntity *pActivator )

+{

+	if ( HasSpawnFlags( SF_BLOOD_PLAYER ) )

+	{

+		CBasePlayer *player;

+

+		if ( pActivator && pActivator->IsPlayer() )

+		{

+			player = ToBasePlayer( pActivator );

+		}

+		else

+		{

+			player = UTIL_GetLocalPlayer();

+		}

+

+		if ( player )

+		{

+			return (player->EyePosition()) + Vector( random->RandomFloat(-10,10), random->RandomFloat(-10,10), random->RandomFloat(-10,10) );

+		}

+	}

+

+	return GetLocalOrigin();

+}

+

+

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

+// Purpose:

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

+void UTIL_BloodSpray( const Vector &pos, const Vector &dir, int color, int amount, int flags )

+{

+	if( color == DONT_BLEED )

+		return;

+

+	CEffectData	data;

+

+	data.m_vOrigin = pos;

+	data.m_vNormal = dir;

+	data.m_flScale = (float)amount;

+	data.m_fFlags = flags;

+	data.m_nColor = color;

+

+	DispatchEffect( "bloodspray", data );

+}

+

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

+// Purpose: Input handler for triggering the blood effect.

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

+void CBlood::InputEmitBlood( inputdata_t &inputdata )

+{

+	if ( HasSpawnFlags( SF_BLOOD_STREAM ) )

+	{

+		UTIL_BloodStream( BloodPosition(inputdata.pActivator), Direction(), Color(), BloodAmount() );

+	}

+	else

+	{

+		UTIL_BloodDrips( BloodPosition(inputdata.pActivator), Direction(), Color(), BloodAmount() );

+	}

+

+	if ( HasSpawnFlags( SF_BLOOD_DECAL ) )

+	{

+		Vector forward = Direction();

+		Vector start = BloodPosition( inputdata.pActivator );

+		trace_t tr;

+

+		UTIL_TraceLine( start, start + forward * BloodAmount() * 2, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );

+		if ( tr.fraction != 1.0 )

+		{

+			UTIL_BloodDecalTrace( &tr, Color() );

+		}

+	}

+

+	//

+	// New-fangled blood effects.

+	//

+	if ( HasSpawnFlags( SF_BLOOD_CLOUD | SF_BLOOD_DROPS | SF_BLOOD_GORE ) )

+	{

+		int nFlags = 0;

+		if (HasSpawnFlags(SF_BLOOD_CLOUD))

+		{

+			nFlags |= FX_BLOODSPRAY_CLOUD;

+		}

+

+		if (HasSpawnFlags(SF_BLOOD_DROPS))

+		{

+			nFlags |= FX_BLOODSPRAY_DROPS;

+		}

+

+		if (HasSpawnFlags(SF_BLOOD_GORE))

+		{

+			nFlags |= FX_BLOODSPRAY_GORE;

+		}

+

+		UTIL_BloodSpray(GetAbsOrigin(), Direction(), Color(), BloodAmount(), nFlags);

+	}

+}

+

+

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

+// Purpose: Console command for emitting the blood spray effect from an NPC.

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

+void CC_BloodSpray( const CCommand &args )

+{

+	CBaseEntity *pEnt = NULL;

+	while ( ( pEnt = gEntList.FindEntityGeneric( pEnt, args[1] ) ) != NULL )

+	{

+		Vector forward;

+		pEnt->GetVectors(&forward, NULL, NULL);

+		UTIL_BloodSpray( (forward * 4 ) + ( pEnt->EyePosition() + pEnt->WorldSpaceCenter() ) * 0.5f, forward, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );

+	}

+}

+

+static ConCommand bloodspray( "bloodspray", CC_BloodSpray, "blood", FCVAR_CHEAT );

+

+

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

+//

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

+class CEnvFunnel : public CBaseEntity

+{

+	DECLARE_DATADESC();

+public:

+	DECLARE_CLASS( CEnvFunnel, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

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

+

+	int		m_iSprite;	// Don't save, precache

+};

+

+LINK_ENTITY_TO_CLASS( env_funnel, CEnvFunnel );

+

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

+// Save/Restore

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

+BEGIN_DATADESC( CEnvFunnel )

+

+//	DEFINE_FIELD( m_iSprite,	FIELD_INTEGER ),

+

+END_DATADESC()

+

+

+

+void CEnvFunnel::Precache ( void )

+{

+	m_iSprite = PrecacheModel ( "sprites/flare6.vmt" );

+}

+

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

+{

+	CBroadcastRecipientFilter filter;

+	te->LargeFunnel( filter, 0.0,

+		&GetAbsOrigin(), m_iSprite, HasSpawnFlags( SF_FUNNEL_REVERSE ) ? 1 : 0 );

+

+	SetThink( &CEnvFunnel::SUB_Remove );

+	SetNextThink( gpGlobals->curtime );

+}

+

+void CEnvFunnel::Spawn( void )

+{

+	Precache();

+	SetSolid( SOLID_NONE );

+	AddEffects( EF_NODRAW );

+}

+

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

+// Beverage Dispenser

+// overloaded m_iHealth, is now how many cans remain in the machine.

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

+class CEnvBeverage : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CEnvBeverage, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

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

+	bool	KeyValue( const char *szKeyName, const char *szValue );

+

+	// Input handlers.

+	void	InputActivate( inputdata_t &inputdata );

+

+	DECLARE_DATADESC();

+

+public:

+	bool	m_CanInDispenser;

+	int		m_nBeverageType;

+};

+

+void CEnvBeverage::Precache ( void )

+{

+	PrecacheModel( "models/can.mdl" );

+}

+

+BEGIN_DATADESC( CEnvBeverage )

+	DEFINE_FIELD( m_CanInDispenser, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_nBeverageType, FIELD_INTEGER ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "Activate", InputActivate ),

+END_DATADESC()

+

+LINK_ENTITY_TO_CLASS( env_beverage, CEnvBeverage );

+

+

+bool CEnvBeverage::KeyValue( const char *szKeyName, const char *szValue )

+{

+	if (FStrEq(szKeyName, "beveragetype"))

+	{

+		m_nBeverageType = atoi(szValue);

+	}

+	else

+	{

+		return BaseClass::KeyValue( szKeyName, szValue );

+	}

+

+	return true;

+}

+

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

+{

+	if ( m_CanInDispenser || m_iHealth <= 0 )

+	{

+		// no more cans while one is waiting in the dispenser, or if I'm out of cans.

+		return;

+	}

+

+	CBaseAnimating *pCan = (CBaseAnimating *)CBaseEntity::Create( "item_sodacan", GetLocalOrigin(), GetLocalAngles(), this );

+

+	if ( m_nBeverageType == 6 )

+	{

+		// random

+		pCan->m_nSkin = random->RandomInt( 0, 5 );

+	}

+	else

+	{

+		pCan->m_nSkin = m_nBeverageType;

+	}

+

+	m_CanInDispenser = true;

+	m_iHealth -= 1;

+

+	//SetThink (SUB_Remove);

+	//SetNextThink( gpGlobals->curtime );

+}

+

+void CEnvBeverage::InputActivate( inputdata_t &inputdata )

+{

+	Use( inputdata.pActivator, inputdata.pCaller, USE_ON, 0 );

+}

+

+void CEnvBeverage::Spawn( void )

+{

+	Precache();

+	SetSolid( SOLID_NONE );

+	AddEffects( EF_NODRAW );

+	m_CanInDispenser = false;

+

+	if ( m_iHealth == 0 )

+	{

+		m_iHealth = 10;

+	}

+}

+

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

+// Soda can

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

+class CItemSoda : public CBaseAnimating

+{

+public:

+	DECLARE_CLASS( CItemSoda, CBaseAnimating );

+

+	void	Spawn( void );

+	void	Precache( void );

+	void	CanThink ( void );

+	void	CanTouch ( CBaseEntity *pOther );

+

+	DECLARE_DATADESC();

+};

+

+

+BEGIN_DATADESC( CItemSoda )

+

+	// Function Pointers

+	DEFINE_FUNCTION( CanThink ),

+	DEFINE_FUNCTION( CanTouch ),

+

+END_DATADESC()

+

+LINK_ENTITY_TO_CLASS( item_sodacan, CItemSoda );

+

+void CItemSoda::Precache ( void )

+{

+	PrecacheModel( "models/can.mdl" );

+

+	PrecacheScriptSound( "ItemSoda.Bounce" );

+}

+

+void CItemSoda::Spawn( void )

+{

+	Precache();

+	SetSolid( SOLID_NONE );

+	SetMoveType( MOVETYPE_FLYGRAVITY );

+

+	SetModel ( "models/can.mdl" );

+	UTIL_SetSize ( this, Vector ( 0, 0, 0 ), Vector ( 0, 0, 0 ) );

+

+	SetThink (&CItemSoda::CanThink);

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

+}

+

+void CItemSoda::CanThink ( void )

+{

+	EmitSound( "ItemSoda.Bounce" );

+

+	SetSolid( SOLID_BBOX );

+	AddSolidFlags( FSOLID_TRIGGER );

+	UTIL_SetSize ( this, Vector ( -8, -8, 0 ), Vector ( 8, 8, 8 ) );

+

+	SetThink ( NULL );

+	SetTouch ( &CItemSoda::CanTouch );

+}

+

+void CItemSoda::CanTouch ( CBaseEntity *pOther )

+{

+	if ( !pOther->IsPlayer() )

+	{

+		return;

+	}

+

+	// spoit sound here

+

+	pOther->TakeHealth( 1, DMG_GENERIC );// a bit of health.

+

+	if ( GetOwnerEntity() )

+	{

+		// tell the machine the can was taken

+		CEnvBeverage *bev = (CEnvBeverage *)GetOwnerEntity();

+		bev->m_CanInDispenser = false;

+	}

+

+	AddSolidFlags( FSOLID_NOT_SOLID );

+	SetMoveType( MOVETYPE_NONE );

+	AddEffects( EF_NODRAW );

+	SetTouch ( NULL );

+	SetThink ( &CItemSoda::SUB_Remove );

+	SetNextThink( gpGlobals->curtime );

+}

+

+#ifndef _XBOX

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

+// func_precipitation - temporary snow solution for first HL2

+// technology demo

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

+

+class CPrecipitation : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CPrecipitation, CBaseEntity );

+	DECLARE_DATADESC();

+	DECLARE_SERVERCLASS();

+

+	CPrecipitation();

+	void	Spawn( void );

+

+	CNetworkVar( PrecipitationType_t, m_nPrecipType );

+};

+

+LINK_ENTITY_TO_CLASS( func_precipitation, CPrecipitation );

+

+BEGIN_DATADESC( CPrecipitation )

+	DEFINE_KEYFIELD( m_nPrecipType, FIELD_INTEGER, "preciptype" ),

+END_DATADESC()

+

+// Just send the normal entity crap

+IMPLEMENT_SERVERCLASS_ST( CPrecipitation, DT_Precipitation)

+	SendPropInt( SENDINFO( m_nPrecipType ), Q_log2( NUM_PRECIPITATION_TYPES ) + 1, SPROP_UNSIGNED )

+END_SEND_TABLE()

+

+

+CPrecipitation::CPrecipitation()

+{

+	m_nPrecipType = PRECIPITATION_TYPE_RAIN; // default to rain.

+}

+

+void CPrecipitation::Spawn( void )

+{

+	PrecacheMaterial( "effects/fleck_ash1" );

+	PrecacheMaterial( "effects/fleck_ash2" );

+	PrecacheMaterial( "effects/fleck_ash3" );

+	PrecacheMaterial( "effects/ember_swirling001" );

+

+	Precache();

+	SetSolid( SOLID_NONE );							// Remove model & collisions

+	SetMoveType( MOVETYPE_NONE );

+	SetModel( STRING( GetModelName() ) );		// Set size

+

+	// Default to rain.

+	if ( m_nPrecipType < 0 || m_nPrecipType > NUM_PRECIPITATION_TYPES )

+		m_nPrecipType = PRECIPITATION_TYPE_RAIN;

+

+	m_nRenderMode = kRenderEnvironmental;

+}

+#endif

+

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

+// EnvWind - global wind info

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

+class CEnvWind : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CEnvWind, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

+	void	WindThink( void );

+	int		UpdateTransmitState( void );

+

+	DECLARE_DATADESC();

+	DECLARE_SERVERCLASS();

+

+private:

+#ifdef POSIX

+	CEnvWindShared m_EnvWindShared; // FIXME - fails to compile as networked var due to operator= problem

+#else

+	CNetworkVarEmbedded( CEnvWindShared, m_EnvWindShared );

+#endif

+};

+

+LINK_ENTITY_TO_CLASS( env_wind, CEnvWind );

+

+BEGIN_DATADESC( CEnvWind )

+

+	DEFINE_KEYFIELD( m_EnvWindShared.m_iMinWind, FIELD_INTEGER, "minwind" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_iMaxWind, FIELD_INTEGER, "maxwind" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_iMinGust, FIELD_INTEGER, "mingust" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_iMaxGust, FIELD_INTEGER, "maxgust" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_flMinGustDelay, FIELD_FLOAT, "mingustdelay" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_flMaxGustDelay, FIELD_FLOAT, "maxgustdelay" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_iGustDirChange, FIELD_INTEGER, "gustdirchange" ),

+	DEFINE_KEYFIELD( m_EnvWindShared.m_flGustDuration, FIELD_FLOAT, "gustduration" ),

+//	DEFINE_KEYFIELD( m_EnvWindShared.m_iszGustSound, FIELD_STRING, "gustsound" ),

+

+// Just here to quiet down classcheck

+	// DEFINE_FIELD( m_EnvWindShared, CEnvWindShared ),

+

+	DEFINE_FIELD( m_EnvWindShared.m_iWindDir, FIELD_INTEGER ),

+	DEFINE_FIELD( m_EnvWindShared.m_flWindSpeed, FIELD_FLOAT ),

+

+	DEFINE_OUTPUT( m_EnvWindShared.m_OnGustStart, "OnGustStart" ),

+	DEFINE_OUTPUT( m_EnvWindShared.m_OnGustEnd,	"OnGustEnd" ),

+

+	// Function Pointers

+	DEFINE_FUNCTION( WindThink ),

+

+END_DATADESC()

+

+

+BEGIN_SEND_TABLE_NOBASE(CEnvWindShared, DT_EnvWindShared)

+	// These are parameters that are used to generate the entire motion

+	SendPropInt		(SENDINFO(m_iMinWind),		10, SPROP_UNSIGNED ),

+	SendPropInt		(SENDINFO(m_iMaxWind),		10, SPROP_UNSIGNED ),

+	SendPropInt		(SENDINFO(m_iMinGust),		10, SPROP_UNSIGNED ),

+	SendPropInt		(SENDINFO(m_iMaxGust),		10, SPROP_UNSIGNED ),

+	SendPropFloat	(SENDINFO(m_flMinGustDelay), 0, SPROP_NOSCALE),		// NOTE: Have to do this, so it's *exactly* the same on client

+	SendPropFloat	(SENDINFO(m_flMaxGustDelay), 0, SPROP_NOSCALE),

+	SendPropInt		(SENDINFO(m_iGustDirChange), 9, SPROP_UNSIGNED ),

+	SendPropInt		(SENDINFO(m_iWindSeed),		32, SPROP_UNSIGNED ),

+

+	// These are related to initial state

+	SendPropInt		(SENDINFO(m_iInitialWindDir),9, SPROP_UNSIGNED ),

+	SendPropFloat	(SENDINFO(m_flInitialWindSpeed),0, SPROP_NOSCALE ),

+	SendPropFloat	(SENDINFO(m_flStartTime),	 0, SPROP_NOSCALE ),

+

+	SendPropFloat	(SENDINFO(m_flGustDuration), 0, SPROP_NOSCALE),

+	// Sound related

+//	SendPropInt		(SENDINFO(m_iszGustSound),	10, SPROP_UNSIGNED ),

+END_SEND_TABLE()

+

+// This table encodes the CBaseEntity data.

+IMPLEMENT_SERVERCLASS_ST_NOBASE(CEnvWind, DT_EnvWind)

+	SendPropDataTable(SENDINFO_DT(m_EnvWindShared), &REFERENCE_SEND_TABLE(DT_EnvWindShared)),

+END_SEND_TABLE()

+

+void CEnvWind::Precache ( void )

+{

+//	if (m_iszGustSound)

+//	{

+//		PrecacheScriptSound( STRING( m_iszGustSound ) );

+//	}

+}

+

+void CEnvWind::Spawn( void )

+{

+	Precache();

+	SetSolid( SOLID_NONE );

+	AddEffects( EF_NODRAW );

+

+	m_EnvWindShared.Init( entindex(), 0, gpGlobals->frametime, GetLocalAngles().y, 0 );

+

+	SetThink( &CEnvWind::WindThink );

+	SetNextThink( gpGlobals->curtime );

+}

+

+int CEnvWind::UpdateTransmitState()

+{

+	return SetTransmitState( FL_EDICT_ALWAYS );

+}

+

+void CEnvWind::WindThink( void )

+{

+	SetNextThink( m_EnvWindShared.WindThink( gpGlobals->curtime ) );

+}

+

+

+

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

+// CEmbers

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

+

+#define	bitsSF_EMBERS_START_ON	0x00000001

+#define	bitsSF_EMBERS_TOGGLE	0x00000002

+

+// UNDONE: This is a brush effect-in-volume entity, move client side.

+class CEmbers : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CEmbers, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

+

+	void	EmberUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );

+

+	CNetworkVar( int, m_nDensity );

+	CNetworkVar( int, m_nLifetime );

+	CNetworkVar( int, m_nSpeed );

+

+	CNetworkVar( bool, m_bEmit );

+

+	DECLARE_DATADESC();

+	DECLARE_SERVERCLASS();

+};

+

+LINK_ENTITY_TO_CLASS( env_embers, CEmbers );

+

+//Data description

+BEGIN_DATADESC( CEmbers )

+

+	DEFINE_KEYFIELD( m_nDensity,	FIELD_INTEGER, "density" ),

+	DEFINE_KEYFIELD( m_nLifetime,	FIELD_INTEGER, "lifetime" ),

+	DEFINE_KEYFIELD( m_nSpeed,		FIELD_INTEGER, "speed" ),

+

+	DEFINE_FIELD( m_bEmit,	FIELD_BOOLEAN ),

+

+	//Function pointers

+	DEFINE_FUNCTION( EmberUse ),

+

+END_DATADESC()

+

+

+//Data table

+IMPLEMENT_SERVERCLASS_ST( CEmbers, DT_Embers )

+	SendPropInt(	SENDINFO( m_nDensity ),		32,	SPROP_UNSIGNED ),

+	SendPropInt(	SENDINFO( m_nLifetime ),	32,	SPROP_UNSIGNED ),

+	SendPropInt(	SENDINFO( m_nSpeed ),		32,	SPROP_UNSIGNED ),

+	SendPropInt(	SENDINFO( m_bEmit ),		2,	SPROP_UNSIGNED ),

+END_SEND_TABLE()

+

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

+// Purpose:

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

+void CEmbers::Spawn( void )

+{

+	Precache();

+	SetModel( STRING( GetModelName() ) );

+

+	SetSolid( SOLID_NONE );

+	SetRenderColorA( 0 );

+	m_nRenderMode	= kRenderTransTexture;

+

+	SetUse( &CEmbers::EmberUse );

+

+	//Start off if we're targetted (unless flagged)

+	m_bEmit = ( HasSpawnFlags( bitsSF_EMBERS_START_ON ) || ( !GetEntityName() ) );

+}

+

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

+// Purpose:

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

+void CEmbers::Precache( void )

+{

+}

+

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

+// Purpose:

+// Input  : *pActivator -

+//			*pCaller -

+//			useType -

+//			value -

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

+void CEmbers::EmberUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )

+{

+	//If we're not toggable, only allow one use

+	if ( !HasSpawnFlags( bitsSF_EMBERS_TOGGLE ) )

+	{

+		SetUse( NULL );

+	}

+

+	//Handle it

+	switch ( useType )

+	{

+	case USE_OFF:

+		m_bEmit = false;

+		break;

+

+	case USE_ON:

+		m_bEmit = true;

+		break;

+

+	case USE_SET:

+		m_bEmit = !!(int)value;

+		break;

+

+	default:

+	case USE_TOGGLE:

+		m_bEmit = !m_bEmit;

+		break;

+	}

+}

+

+

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

+// Purpose:

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

+class CPhysicsWire : public CBaseEntity

+{

+public:

+	DECLARE_CLASS( CPhysicsWire, CBaseEntity );

+

+	void	Spawn( void );

+	void	Precache( void );

+

+	DECLARE_DATADESC();

+

+protected:

+

+	bool SetupPhysics( void );

+

+	int		m_nDensity;

+};

+

+LINK_ENTITY_TO_CLASS( env_physwire, CPhysicsWire );

+

+BEGIN_DATADESC( CPhysicsWire )

+

+	DEFINE_KEYFIELD( m_nDensity,	FIELD_INTEGER, "Density" ),

+//	DEFINE_KEYFIELD( m_frequency, FIELD_INTEGER, "frequency" ),

+

+//	DEFINE_FIELD( m_flFoo, FIELD_FLOAT ),

+

+	// Function Pointers

+//	DEFINE_FUNCTION( WireThink ),

+

+END_DATADESC()

+

+

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

+// Purpose:

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

+void CPhysicsWire::Spawn( void )

+{

+	BaseClass::Spawn();

+

+	Precache();

+

+//	if ( SetupPhysics() == false )

+//		return;

+}

+

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

+// Purpose:

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

+void CPhysicsWire::Precache( void )

+{

+	BaseClass::Precache();

+}

+

+class CPhysBallSocket;

+

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

+// Purpose:

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

+bool CPhysicsWire::SetupPhysics( void )

+{

+/*

+	CPointEntity	*anchorEnt, *freeEnt;

+	CPhysBallSocket *socket;

+

+	char	anchorName[256];

+	char	freeName[256];

+

+	int		iAnchorName, iFreeName;

+

+	anchorEnt = (CPointEntity *) CreateEntityByName( "info_target" );

+

+	if ( anchorEnt == NULL )

+		return false;

+

+	//Create and connect all segments

+	for ( int i = 0; i < m_nDensity; i++ )

+	{

+		// Create other end of our link

+		freeEnt = (CPointEntity *) CreateEntityByName( "info_target" );

+

+		// Create a ballsocket and attach the two

+		//socket = (CPhysBallSocket *) CreateEntityByName( "phys_ballsocket" );

+

+		Q_snprintf( anchorName,sizeof(anchorName), "__PWIREANCHOR%d", i );

+		Q_snprintf( freeName,sizeof(freeName), "__PWIREFREE%d", i+1 );

+

+		iAnchorName = MAKE_STRING( anchorName );

+		iFreeName	= MAKE_STRING( freeName );

+

+		//Fake the names

+		//socket->m_nameAttach1 = anchorEnt->m_iGlobalname	= iAnchorName;

+		//socket->m_nameAttach2 = freeEnt->m_iGlobalname	= iFreeName

+

+		//socket->Activate();

+

+		//The free ent is now the anchor for the next link

+		anchorEnt = freeEnt;

+	}

+*/

+

+	return true;

+}

+

+//

+// Muzzle flash

+//

+

+class CEnvMuzzleFlash : public CPointEntity

+{

+	DECLARE_CLASS( CEnvMuzzleFlash, CPointEntity );

+

+public:

+	virtual void Spawn();

+

+	// Input handlers

+	void	InputFire( inputdata_t &inputdata );

+

+	DECLARE_DATADESC();

+

+	float	m_flScale;

+	string_t m_iszParentAttachment;

+};

+

+BEGIN_DATADESC( CEnvMuzzleFlash )

+

+	DEFINE_KEYFIELD( m_flScale, FIELD_FLOAT, "scale" ),

+	DEFINE_KEYFIELD( m_iszParentAttachment, FIELD_STRING, "parentattachment" ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "Fire", InputFire ),

+

+END_DATADESC()

+

+

+LINK_ENTITY_TO_CLASS( env_muzzleflash, CEnvMuzzleFlash );

+

+

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

+// Spawn!

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

+void CEnvMuzzleFlash::Spawn()

+{

+	if ( (m_iszParentAttachment != NULL_STRING) && GetParent() && GetParent()->GetBaseAnimating() )

+	{

+		CBaseAnimating *pAnim = GetParent()->GetBaseAnimating();

+		int nParentAttachment = pAnim->LookupAttachment( STRING(m_iszParentAttachment) );

+		if ( nParentAttachment > 0 )

+		{

+			SetParent( GetParent(), nParentAttachment );

+			SetLocalOrigin( vec3_origin );

+			SetLocalAngles( vec3_angle );

+		}

+	}

+}

+

+

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

+// Purpose:

+// Input  : &inputdata -

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

+void CEnvMuzzleFlash::InputFire( inputdata_t &inputdata )

+{

+	g_pEffects->MuzzleFlash( GetAbsOrigin(), GetAbsAngles(), m_flScale, MUZZLEFLASH_TYPE_DEFAULT );

+}

+

+

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

+// Splash!

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

+#define SF_ENVSPLASH_FINDWATERSURFACE	0x00000001

+#define SF_ENVSPLASH_DIMINISH			0x00000002

+class CEnvSplash : public CPointEntity

+{

+	DECLARE_CLASS( CEnvSplash, CPointEntity );

+

+public:

+	// Input handlers

+	void	InputSplash( inputdata_t &inputdata );

+

+protected:

+

+	float	m_flScale;

+

+	DECLARE_DATADESC();

+};

+

+BEGIN_DATADESC( CEnvSplash )

+	DEFINE_KEYFIELD( m_flScale, FIELD_FLOAT, "scale" ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "Splash", InputSplash ),

+END_DATADESC()

+

+LINK_ENTITY_TO_CLASS( env_splash, CEnvSplash );

+

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

+// Purpose:

+// Input  : &inputdata -

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

+#define SPLASH_MAX_DEPTH	120.0f

+void CEnvSplash::InputSplash( inputdata_t &inputdata )

+{

+	CEffectData	data;

+

+	data.m_fFlags = 0;

+

+	float scale = m_flScale;

+

+	if( HasSpawnFlags( SF_ENVSPLASH_FINDWATERSURFACE ) )

+	{

+		if( UTIL_PointContents(GetAbsOrigin()) & MASK_WATER )

+		{

+			// No splash if I'm supposed to find the surface of the water, but I'm underwater.

+			return;

+		}

+

+		// Trace down and find the water's surface. This is designed for making

+		// splashes on the surface of water that can change water level.

+		trace_t tr;

+		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 4096 ), (MASK_WATER|MASK_SOLID_BRUSHONLY), this, COLLISION_GROUP_NONE, &tr );

+		data.m_vOrigin = tr.endpos;

+

+		if ( tr.contents & CONTENTS_SLIME )

+		{

+			data.m_fFlags |= FX_WATER_IN_SLIME;

+		}

+	}

+	else

+	{

+		data.m_vOrigin = GetAbsOrigin();

+	}

+

+	if( HasSpawnFlags( SF_ENVSPLASH_DIMINISH ) )

+	{

+		// Get smaller if I'm in deeper water.

+		float depth = 0.0f;

+

+		trace_t tr;

+		UTIL_TraceLine( data.m_vOrigin, data.m_vOrigin - Vector( 0, 0, 4096 ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );

+

+		depth = fabs( tr.startpos.z - tr.endpos.z );

+

+		float factor = 1.0f - (depth / SPLASH_MAX_DEPTH);

+

+		if( factor < 0.1 )

+		{

+			// Don't bother making one this small.

+			return;

+		}

+

+		scale *= factor;

+	}

+

+	data.m_vNormal = Vector( 0, 0, 1 );

+	data.m_flScale = scale;

+

+	DispatchEffect( "watersplash", data );

+}

+

+

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

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

+class CEnvGunfire : public CPointEntity

+{

+public:

+	DECLARE_CLASS( CEnvGunfire, CPointEntity );

+

+	CEnvGunfire()

+	{

+		// !!!HACKHACK

+		// These fields came along kind of late, so they get

+		// initialized in the constructor for now. (sjb)

+		m_flBias = 1.0f;

+		m_bCollide = false;

+	}

+

+	void Precache();

+	void Spawn();

+	void Activate();

+	void StartShooting();

+	void StopShooting();

+	void ShootThink();

+	void UpdateTarget();

+

+	void InputEnable( inputdata_t &inputdata );

+	void InputDisable( inputdata_t &inputdata );

+

+	int	m_iMinBurstSize;

+	int m_iMaxBurstSize;

+

+	float m_flMinBurstDelay;

+	float m_flMaxBurstDelay;

+

+	float m_flRateOfFire;

+

+	string_t	m_iszShootSound;

+	string_t	m_iszTracerType;

+

+	bool m_bDisabled;

+

+	int	m_iShotsRemaining;

+

+	int		m_iSpread;

+	Vector	m_vecSpread;

+	Vector	m_vecTargetPosition;

+	float	m_flTargetDist;

+

+	float	m_flBias;

+	bool	m_bCollide;

+

+	EHANDLE m_hTarget;

+

+

+	DECLARE_DATADESC();

+};

+

+BEGIN_DATADESC( CEnvGunfire )

+	DEFINE_KEYFIELD( m_iMinBurstSize, FIELD_INTEGER, "minburstsize" ),

+	DEFINE_KEYFIELD( m_iMaxBurstSize, FIELD_INTEGER, "maxburstsize" ),

+	DEFINE_KEYFIELD( m_flMinBurstDelay, FIELD_TIME, "minburstdelay" ),

+	DEFINE_KEYFIELD( m_flMaxBurstDelay, FIELD_TIME, "maxburstdelay" ),

+	DEFINE_KEYFIELD( m_flRateOfFire, FIELD_FLOAT, "rateoffire" ),

+	DEFINE_KEYFIELD( m_iszShootSound, FIELD_STRING, "shootsound" ),

+	DEFINE_KEYFIELD( m_iszTracerType, FIELD_STRING, "tracertype" ),

+	DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "startdisabled" ),

+	DEFINE_KEYFIELD( m_iSpread, FIELD_INTEGER, "spread" ),

+	DEFINE_KEYFIELD( m_flBias, FIELD_FLOAT, "bias" ),

+	DEFINE_KEYFIELD( m_bCollide, FIELD_BOOLEAN, "collisions" ),

+

+	DEFINE_FIELD( m_iShotsRemaining, FIELD_INTEGER ),

+	DEFINE_FIELD( m_vecSpread, FIELD_VECTOR ),

+	DEFINE_FIELD( m_vecTargetPosition, FIELD_VECTOR ),

+	DEFINE_FIELD( m_flTargetDist, FIELD_FLOAT ),

+

+	DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ),

+

+	DEFINE_THINKFUNC( ShootThink ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),

+	DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),

+END_DATADESC()

+LINK_ENTITY_TO_CLASS( env_gunfire, CEnvGunfire );

+

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

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

+void CEnvGunfire::Precache()

+{

+	PrecacheScriptSound( STRING( m_iszShootSound ) );

+}

+

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

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

+void CEnvGunfire::Spawn()

+{

+	Precache();

+

+	m_iShotsRemaining = 0;

+	m_flRateOfFire = 1.0f / m_flRateOfFire;

+

+	switch( m_iSpread )

+	{

+	case 1:

+		m_vecSpread = VECTOR_CONE_1DEGREES;

+		break;

+	case 5:

+		m_vecSpread = VECTOR_CONE_5DEGREES;

+		break;

+	case 10:

+		m_vecSpread = VECTOR_CONE_10DEGREES;

+		break;

+	case 15:

+		m_vecSpread = VECTOR_CONE_15DEGREES;

+		break;

+

+	default:

+		m_vecSpread = vec3_origin;

+		break;

+	}

+

+	if( !m_bDisabled )

+	{

+		StartShooting();

+	}

+}

+

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

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

+void CEnvGunfire::Activate( void )

+{

+	// Find my target

+	if (m_target != NULL_STRING)

+	{

+		m_hTarget = gEntList.FindEntityByName( NULL, m_target );

+	}

+

+	BaseClass::Activate();

+}

+

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

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

+void CEnvGunfire::StartShooting()

+{

+	m_iShotsRemaining = random->RandomInt( m_iMinBurstSize, m_iMaxBurstSize );

+

+	SetThink( &CEnvGunfire::ShootThink );

+	SetNextThink( gpGlobals->curtime );

+}

+

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

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

+void CEnvGunfire::UpdateTarget()

+{

+	if( m_hTarget )

+	{

+		if( m_hTarget->WorldSpaceCenter() != m_vecTargetPosition )

+		{

+			// Target has moved.

+			// Locate my target and cache the position and distance.

+			m_vecTargetPosition = m_hTarget->WorldSpaceCenter();

+			m_flTargetDist = (GetAbsOrigin() - m_vecTargetPosition).Length();

+		}

+	}

+}

+

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

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

+void CEnvGunfire::StopShooting()

+{

+	SetThink( NULL );

+}

+

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

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

+void CEnvGunfire::ShootThink()

+{

+	if( !m_hTarget )

+	{

+		StopShooting();

+	}

+

+	SetNextThink( gpGlobals->curtime + m_flRateOfFire );

+

+	UpdateTarget();

+

+	Vector vecDir = m_vecTargetPosition - GetAbsOrigin();

+	VectorNormalize( vecDir );

+

+	CShotManipulator manipulator( vecDir );

+

+	vecDir = manipulator.ApplySpread( m_vecSpread, m_flBias );

+

+	Vector vecEnd;

+

+	if( m_bCollide )

+	{

+		trace_t tr;

+

+		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vecDir * 8192, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );

+

+		if( tr.fraction != 1.0 )

+		{

+			DoImpactEffect( tr, DMG_BULLET );

+		}

+

+		vecEnd = tr.endpos;

+	}

+	else

+	{

+		vecEnd = GetAbsOrigin() + vecDir * m_flTargetDist;

+	}

+

+	if( m_iszTracerType != NULL_STRING )

+	{

+		UTIL_Tracer( GetAbsOrigin(), vecEnd, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true, STRING(m_iszTracerType) );

+	}

+	else

+	{

+		UTIL_Tracer( GetAbsOrigin(), vecEnd, 0, TRACER_DONT_USE_ATTACHMENT, 5000, true );

+	}

+

+	EmitSound( STRING(m_iszShootSound) );

+

+	m_iShotsRemaining--;

+

+	if( m_iShotsRemaining == 0 )

+	{

+		StartShooting();

+		SetNextThink( gpGlobals->curtime + random->RandomFloat( m_flMinBurstDelay, m_flMaxBurstDelay ) );

+	}

+}

+

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

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

+void CEnvGunfire::InputEnable( inputdata_t &inputdata )

+{

+	m_bDisabled = false;

+	StartShooting();

+}

+

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

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

+void CEnvGunfire::InputDisable( inputdata_t &inputdata )

+{

+	m_bDisabled = true;

+	SetThink( NULL );

+}

+

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

+// Quadratic spline beam effect

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

+BEGIN_DATADESC( CEnvQuadraticBeam )

+	DEFINE_FIELD( m_targetPosition, FIELD_POSITION_VECTOR ),

+	DEFINE_FIELD( m_controlPosition, FIELD_POSITION_VECTOR ),

+	DEFINE_FIELD( m_scrollRate, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flWidth, FIELD_FLOAT ),

+END_DATADESC()

+

+LINK_ENTITY_TO_CLASS( env_quadraticbeam, CEnvQuadraticBeam );

+

+IMPLEMENT_SERVERCLASS_ST( CEnvQuadraticBeam, DT_QuadraticBeam )

+	SendPropVector(SENDINFO(m_targetPosition), -1, SPROP_COORD),

+	SendPropVector(SENDINFO(m_controlPosition), -1, SPROP_COORD),

+	SendPropFloat(SENDINFO(m_scrollRate), 8, 0, -4, 4),

+	SendPropFloat(SENDINFO(m_flWidth), -1, SPROP_NOSCALE),

+END_SEND_TABLE()

+

+void CEnvQuadraticBeam::Spawn()

+{

+	BaseClass::Spawn();

+	m_nRenderMode = kRenderTransAdd;

+	SetRenderColor( 255, 255, 255 );

+}

+

+CEnvQuadraticBeam *CreateQuadraticBeam( const char *pSpriteName, const Vector &start, const Vector &control, const Vector &end, float width, CBaseEntity *pOwner )

+{

+	CEnvQuadraticBeam *pBeam = (CEnvQuadraticBeam *)CBaseEntity::Create( "env_quadraticbeam", start, vec3_angle, pOwner );

+	UTIL_SetModel( pBeam, pSpriteName );

+	pBeam->SetSpline( control, end );

+	pBeam->SetScrollRate( 0.0 );

+	pBeam->SetWidth(width);

+	return pBeam;

+}

+

+void EffectsPrecache( void *pUser )

+{

+	CBaseEntity::PrecacheScriptSound( "Underwater.BulletImpact" );

+

+	CBaseEntity::PrecacheScriptSound( "FX_RicochetSound.Ricochet" );

+

+	CBaseEntity::PrecacheScriptSound( "Physics.WaterSplash" );

+	CBaseEntity::PrecacheScriptSound( "BaseExplosionEffect.Sound" );

+	CBaseEntity::PrecacheScriptSound( "Splash.SplashSound" );

+

+	if ( gpGlobals->maxClients > 1 )

+	{

+		CBaseEntity::PrecacheScriptSound( "HudChat.Message" );

+	}

+}

+

+PRECACHE_REGISTER_FN( EffectsPrecache );

+

+

+class CEnvViewPunch : public CPointEntity

+{

+public:

+

+	DECLARE_CLASS( CEnvViewPunch, CPointEntity );

+

+	virtual void Spawn();

+

+	// Input handlers

+	void InputViewPunch( inputdata_t &inputdata );

+

+private:

+

+	float m_flRadius;

+	QAngle m_angViewPunch;

+

+	void DoViewPunch();

+

+	DECLARE_DATADESC();

+};

+

+LINK_ENTITY_TO_CLASS( env_viewpunch, CEnvViewPunch );

+

+BEGIN_DATADESC( CEnvViewPunch )

+

+	DEFINE_KEYFIELD( m_angViewPunch, FIELD_VECTOR, "punchangle" ),

+	DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "radius" ),

+

+	DEFINE_INPUTFUNC( FIELD_VOID, "ViewPunch", InputViewPunch ),

+

+END_DATADESC()

+

+#define SF_PUNCH_EVERYONE	0x0001		// Don't check radius

+#define SF_PUNCH_IN_AIR		0x0002		// Punch players in air

+

+

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

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

+void CEnvViewPunch::Spawn( void )

+{

+	SetSolid( SOLID_NONE );

+	SetMoveType( MOVETYPE_NONE );

+

+	if ( GetSpawnFlags() & SF_PUNCH_EVERYONE )

+	{

+		m_flRadius = 0;

+	}

+}

+

+

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

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

+void CEnvViewPunch::DoViewPunch()

+{

+	bool bAir = (GetSpawnFlags() & SF_PUNCH_IN_AIR) ? true : false;

+	UTIL_ViewPunch( GetAbsOrigin(), m_angViewPunch, m_flRadius, bAir );

+}

+

+

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

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

+void CEnvViewPunch::InputViewPunch( inputdata_t &inputdata )

+{

+	DoViewPunch();

+}