source-engine/game/shared/dod/weapon_mg42.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"
#include "weapon_mg42.h"
#include "engine/ivdebugoverlay.h"

#if defined( CLIENT_DLL )

	#include "tier1/KeyValues.h"
	#include "particles_simple.h"
	#include "particles_localspace.h"
	#include "fx.h"
	#include "c_dod_player.h"

#else
	
	#include "dod_player.h"

#endif


#ifdef CLIENT_DLL	
void ToolFramework_PostToolMessage( HTOOLHANDLE hEntity, KeyValues *msg );
#endif


IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMG42, DT_WeaponMG42 )

#ifdef GAME_DLL

BEGIN_DATADESC( CWeaponMG42 )
	DEFINE_THINKFUNC( CoolThink ),
END_DATADESC()

#endif

BEGIN_NETWORK_TABLE( CWeaponMG42, DT_WeaponMG42 )
#ifdef CLIENT_DLL	
	RecvPropInt			( RECVINFO( m_iWeaponHeat ) ),
	RecvPropTime		( RECVINFO( m_flNextCoolTime ) ),
	RecvPropBool		( RECVINFO( m_bOverheated ) ),
#else
	SendPropInt			( SENDINFO( m_iWeaponHeat ), 7, SPROP_UNSIGNED ),
	SendPropFloat		( SENDINFO( m_flNextCoolTime ) ),
	SendPropBool		( SENDINFO( m_bOverheated ) ),
#endif
END_NETWORK_TABLE()

#ifdef CLIENT_DLL
BEGIN_PREDICTION_DATA( CWeaponMG42 )
	DEFINE_PRED_FIELD( m_iWeaponHeat, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD_TOL( m_flNextCoolTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
	DEFINE_PRED_FIELD( m_bOverheated, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()
#endif

LINK_ENTITY_TO_CLASS( weapon_mg42, CWeaponMG42 );
PRECACHE_WEAPON_REGISTER( weapon_mg42 );

acttable_t CWeaponMG42::m_acttable[] = 
{
	{ ACT_DOD_STAND_AIM,					ACT_DOD_STAND_AIM_MG,				false },
	{ ACT_DOD_CROUCH_AIM,					ACT_DOD_CROUCH_AIM_MG,				false },
	{ ACT_DOD_CROUCHWALK_AIM,				ACT_DOD_CROUCHWALK_AIM_MG,			false },
	{ ACT_DOD_WALK_AIM,						ACT_DOD_WALK_AIM_MG,				false },
	{ ACT_DOD_RUN_AIM,						ACT_DOD_RUN_AIM_MG,					false },
	{ ACT_PRONE_IDLE,						ACT_DOD_PRONE_AIM_MG,				false },
	{ ACT_PRONE_FORWARD,					ACT_DOD_PRONEWALK_IDLE_MG,			false },
	{ ACT_DOD_STAND_IDLE,					ACT_DOD_STAND_IDLE_MG,				false },
	{ ACT_DOD_CROUCH_IDLE,					ACT_DOD_CROUCH_IDLE_MG,				false },
	{ ACT_DOD_CROUCHWALK_IDLE,				ACT_DOD_CROUCHWALK_IDLE_MG,			false },
	{ ACT_DOD_WALK_IDLE,					ACT_DOD_WALK_IDLE_MG,				false },
	{ ACT_DOD_RUN_IDLE,						ACT_DOD_RUN_IDLE_MG,				false },
	{ ACT_SPRINT,							ACT_DOD_SPRINT_IDLE_MG,				false },

	// Deployed Aim
	{ ACT_DOD_DEPLOYED,						ACT_DOD_DEPLOY_MG,						false },
	{ ACT_DOD_PRONE_DEPLOYED,				ACT_DOD_PRONE_DEPLOY_MG,				false },

	// Attack ( prone? deployed? )
	{ ACT_RANGE_ATTACK1,					ACT_DOD_PRIMARYATTACK_MG,				false },
	{ ACT_DOD_PRIMARYATTACK_CROUCH,			ACT_DOD_PRIMARYATTACK_MG,				false },
	{ ACT_DOD_PRIMARYATTACK_PRONE,			ACT_DOD_PRIMARYATTACK_PRONE_MG,			false },
	{ ACT_DOD_PRIMARYATTACK_DEPLOYED,		ACT_DOD_PRIMARYATTACK_DEPLOYED_MG,		false },
	{ ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED,	ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_MG,false },

	// Reload ( prone? deployed? )	
	{ ACT_DOD_RELOAD_DEPLOYED,				ACT_DOD_RELOAD_DEPLOYED_MG,				false },
	{ ACT_DOD_RELOAD_PRONE_DEPLOYED,		ACT_DOD_RELOAD_PRONE_DEPLOYED_MG,		false },

	// Hand Signals
	{ ACT_DOD_HS_IDLE,						ACT_DOD_HS_IDLE_MG42,					false },
	{ ACT_DOD_HS_CROUCH,					ACT_DOD_HS_CROUCH_MG42,					false },
};

IMPLEMENT_ACTTABLE( CWeaponMG42 );

void CWeaponMG42::Spawn( void )
{
	m_iWeaponHeat = 0;
	m_flNextCoolTime = 0;

	m_bOverheated = false;

#ifdef CLIENT_DLL
	m_pEmitter = NULL;
	m_flParticleAccumulator = 0.0;
	m_hParticleMaterial = ParticleMgr()->GetPMaterial( "sprites/effects/bazookapuff" );
#endif	

	BaseClass::Spawn();
}

#ifdef CLIENT_DLL

	CWeaponMG42::~CWeaponMG42()
	{
		if ( clienttools->IsInRecordingMode() && m_pEmitter.IsValid() && m_pEmitter->GetToolParticleEffectId() != TOOLPARTICLESYSTEMID_INVALID )
		{
			KeyValues *msg = new KeyValues( "ParticleSystem_ActivateEmitter" );
			msg->SetInt( "id", m_pEmitter->GetToolParticleEffectId() );
			msg->SetFloat( "time", gpGlobals->curtime );
			msg->SetInt( "active", 0 );

			msg->SetInt( "emitter", 0 );
			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

			msg->SetInt( "emitter", 1 );
			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

			msg->SetInt( "emitter", 2 );
			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

			msg->SetInt( "emitter", 3 );
			ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

			msg->deleteThis();
		}
	}

	void CWeaponMG42::OnDataChanged( DataUpdateType_t updateType )
	{
		BaseClass::OnDataChanged( updateType );

		// BUG! This can happen more than once!
		if ( updateType == DATA_UPDATE_CREATED )
		{
			if ( !m_pEmitter.IsValid() )
			{
				m_pEmitter = CSimpleEmitter::Create( "MGOverheat" );
			}

			Assert( m_pEmitter.IsValid() );
		}

		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
	}

	// Client Think emits smoke particles based on heat
	// ( except if we are holstered )
	void CWeaponMG42::ClientThink( void )
	{
		m_pEmitter->SetSortOrigin( GetAbsOrigin() );

		float flEmitRate = 0.0;	//particles per second

		// Only smoke if we are dropped ( no owner ) or if we have an owner and are active
		if ( GetOwner() == NULL || GetOwner()->GetActiveWeapon() == this )
		{
			if ( m_iWeaponHeat > 85 )
			{	
				flEmitRate = 30;
			}
			else if ( m_iWeaponHeat > 80 )
			{
				flEmitRate = 20;
			}
			else if ( m_iWeaponHeat > 65 )
			{
				flEmitRate = 10;
			}
			else if ( m_iWeaponHeat > 50 )
			{
				flEmitRate = 5;
			}
		}

		m_flParticleAccumulator += ( gpGlobals->frametime * flEmitRate );

		while( m_flParticleAccumulator > 0.0 )
		{
			EmitSmokeParticle();

			m_flParticleAccumulator -= 1.0;
		}
	}

	void CWeaponMG42::EmitSmokeParticle( void )
	{
		Vector vFront, vBack;	
		QAngle angles;

		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();

		bool bViewModel = false;

		// if this is locally owned
		if ( GetPlayerOwner() == pLocalPlayer )
		{
			C_BaseViewModel *vm = pLocalPlayer->GetViewModel( 0 );

			if ( !vm )
				return;

			vm->GetAttachment( 1, vFront, angles );
			vm->GetAttachment( 2, vBack, angles );

			bViewModel = true;
		}
		else
		{
			// could be dropped, or held by another player
			GetAttachment( 1, vFront, angles );
			GetAttachment( 2, vBack, angles );
		}

		// Get a position somewhere on the barrel
		Vector vPos = vBack + random->RandomFloat(0.0, 1.0 ) * ( vFront - vBack );

		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
		if ( pParticle )
		{
			pParticle->m_vecVelocity = Vector( 0,0,12 );
			pParticle->m_flRoll = random->RandomFloat( 0, 0.5 );
			pParticle->m_flRollDelta = ( random->RandomInt(0,1) == 0 ? 1 : -1 ) * random->RandomFloat( 0.5, 1.0 );
			pParticle->m_flDieTime = 1.8f;
			pParticle->m_flLifetime = 0;
			pParticle->m_uchColor[0] = 200;
			pParticle->m_uchColor[1] = 200; 
			pParticle->m_uchColor[2] = 200;
			pParticle->m_uchStartAlpha = 60;
			pParticle->m_uchEndAlpha = 0;
			pParticle->m_uchStartSize = 4;
			pParticle->m_uchEndSize = 25;
			pParticle->m_iFlags = 0;	//bViewModel ? FLE_VIEWMODEL : 0;
		}
	}

#else

	// This function does the cooling when the weapon is dropped or holstered
	// regular, predicted cooling is done in ItemPostFrame
	void CWeaponMG42::CoolThink( void )
	{
		if ( m_iWeaponHeat > 0 )
			m_iWeaponHeat--;
		
		SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
	}

#endif	

void CWeaponMG42::Precache()
{
	PrecacheMaterial( "sprites/effects/bazookapuff" );

	PrecacheScriptSound( "Weapon_Mg42.OverHeat" );

	BaseClass::Precache();
}

bool CWeaponMG42::Reload( void )
{
	if( !IsDeployed() )
	{
#ifdef CLIENT_DLL
		CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );

		if ( pPlayer )
			pPlayer->HintMessage( HINT_MG_DEPLOY_TO_RELOAD );
#endif
		return false;
	}

	return BaseClass::Reload();
}

void CWeaponMG42::FinishReload( void )
{
	BaseClass::FinishReload();

	//Reset the heat when you complete a reload
	m_iWeaponHeat = 0;
}

void CWeaponMG42::PrimaryAttack( void )
{
	if( m_bOverheated )
	{
		return;
	}

	if ( m_iClip1 <= 0 )
	{
		if (m_bFireOnEmpty)
		{
			PlayEmptySound();
			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
		}

		return;
	}


	CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
	Assert( pPlayer );

	if( m_iWeaponHeat >= 99 )
	{
		//can't fire anymore, wait until heat is below 80
#ifdef CLIENT_DLL 
		pPlayer->HintMessage( HINT_WEAPON_OVERHEAT );
#endif
		m_bOverheated = true;
		m_bInAttack = true;

		EmitSound( "Weapon_Mg42.OverHeat" );
		return;
	}

	m_iWeaponHeat += 1; //2;
	m_flNextCoolTime = gpGlobals->curtime + 0.16f;
	
	if( !IsDeployed() )
	{
#ifdef CLIENT_DLL 
		pPlayer->HintMessage( HINT_MG_FIRE_UNDEPLOYED );
#endif
		pPlayer->m_Shared.SetSlowedTime( 0.2 );

		float flStamina = pPlayer->m_Shared.GetStamina();

		pPlayer->m_Shared.SetStamina( flStamina - 15 );
	}

	BaseClass::PrimaryAttack();
}

void CWeaponMG42::ItemPostFrame( void )
{
	ItemFrameCool();

	if( m_iWeaponHeat < 80 )
		m_bOverheated = false;	

	BaseClass::ItemPostFrame();
}

void CWeaponMG42::ItemBusyFrame( void )
{
	ItemFrameCool();

	BaseClass::ItemBusyFrame();
}

void CWeaponMG42::ItemFrameCool( void )
{
	if( gpGlobals->curtime > m_flNextCoolTime )
	{
		if ( m_iWeaponHeat > 0 )
			m_iWeaponHeat--;

		m_flNextCoolTime = gpGlobals->curtime + 0.16f;
	}
}

bool CWeaponMG42::Deploy( void )
{
	// stop the fake cooling when we deploy the weapon
	SetContextThink( NULL, 0.0, COOL_CONTEXT );

	return BaseClass::Deploy();
}

bool CWeaponMG42::Holster( CBaseCombatWeapon *pSwitchingTo )
{
#ifndef CLIENT_DLL
	SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
#endif

	return BaseClass::Holster(pSwitchingTo);
}

void CWeaponMG42::Drop( const Vector &vecVelocity )
{
#ifndef CLIENT_DLL
	SetContextThink( &CWeaponMG42::CoolThink, gpGlobals->curtime + 0.1, COOL_CONTEXT );
#endif

	BaseClass::Drop( vecVelocity );
}

Activity CWeaponMG42::GetReloadActivity( void )
{
	return ACT_VM_RELOAD;
}

Activity CWeaponMG42::GetDrawActivity( void )
{
	Activity actDraw;

	if( 0 && m_iClip1 <= 0 )
		actDraw = ACT_VM_DRAW_EMPTY;	
	else
		actDraw = ACT_VM_DRAW;

	return actDraw;
}

Activity CWeaponMG42::GetDeployActivity( void )
{
	Activity actDeploy;

	switch ( m_iClip1 )
	{
	case 8:
		actDeploy = ACT_VM_DEPLOY_8;
		break;
	case 7:
		actDeploy = ACT_VM_DEPLOY_7;
		break;
	case 6:
		actDeploy = ACT_VM_DEPLOY_6;
		break;
	case 5:
		actDeploy = ACT_VM_DEPLOY_5;
		break;
	case 4:
		actDeploy = ACT_VM_DEPLOY_4;
		break;
	case 3:
		actDeploy = ACT_VM_DEPLOY_3;
		break;
	case 2:
		actDeploy = ACT_VM_DEPLOY_2;
		break;
	case 1:
		actDeploy = ACT_VM_DEPLOY_1;
		break;
	case 0:
		actDeploy = ACT_VM_DEPLOY_EMPTY;
		break;
	default:
		actDeploy = ACT_VM_DEPLOY;
		break;
	}

	return actDeploy;
}

Activity CWeaponMG42::GetUndeployActivity( void )
{
	Activity actUndeploy;

	switch ( m_iClip1 )
	{
	case 8:
		actUndeploy = ACT_VM_UNDEPLOY_8;
		break;
	case 7:
		actUndeploy = ACT_VM_UNDEPLOY_7;
		break;
	case 6:
		actUndeploy = ACT_VM_UNDEPLOY_6;
		break;
	case 5:
		actUndeploy = ACT_VM_UNDEPLOY_5;
		break;
	case 4:
		actUndeploy = ACT_VM_UNDEPLOY_4;
		break;
	case 3:
		actUndeploy = ACT_VM_UNDEPLOY_3;
		break;
	case 2:
		actUndeploy = ACT_VM_UNDEPLOY_2;
		break;
	case 1:
		actUndeploy = ACT_VM_UNDEPLOY_1;
		break;
	case 0:
		actUndeploy = ACT_VM_UNDEPLOY_EMPTY;
		break;
	default:
		actUndeploy = ACT_VM_UNDEPLOY;
		break;
	}

	return actUndeploy;
}

Activity CWeaponMG42::GetIdleActivity( void )
{
	Activity actIdle;

	if( IsDeployed() )
	{
		switch ( m_iClip1 )
		{
		case 8:
			actIdle = ACT_VM_IDLE_DEPLOYED_8;
			break;
		case 7:
			actIdle = ACT_VM_IDLE_DEPLOYED_7;
			break;
		case 6:
			actIdle = ACT_VM_IDLE_DEPLOYED_6;
			break;
		case 5:
			actIdle = ACT_VM_IDLE_DEPLOYED_5;
			break;
		case 4:
			actIdle = ACT_VM_IDLE_DEPLOYED_4;
			break;
		case 3:
			actIdle = ACT_VM_IDLE_DEPLOYED_3;
			break;
		case 2:
			actIdle = ACT_VM_IDLE_DEPLOYED_2;
			break;
		case 1:
			actIdle = ACT_VM_IDLE_DEPLOYED_1;
			break;
		case 0:
			actIdle = ACT_VM_IDLE_DEPLOYED_EMPTY;
			break;
		default:
			actIdle = ACT_VM_IDLE_DEPLOYED;
			break;
		}
	}
	else
	{
		switch ( m_iClip1 )
		{
		case 8:
			actIdle = ACT_VM_IDLE_8;
			break;
		case 7:
			actIdle = ACT_VM_IDLE_7;
			break;
		case 6:
			actIdle = ACT_VM_IDLE_6;
			break;
		case 5:
			actIdle = ACT_VM_IDLE_5;
			break;
		case 4:
			actIdle = ACT_VM_IDLE_4;
			break;
		case 3:
			actIdle = ACT_VM_IDLE_3;
			break;
		case 2:
			actIdle = ACT_VM_IDLE_2;
			break;
		case 1:
			actIdle = ACT_VM_IDLE_1;
			break;
		case 0:
			actIdle = ACT_VM_IDLE_EMPTY;
			break;
		default:
			actIdle = ACT_VM_IDLE;
			break;
		}
	}

	return actIdle;
}

Activity CWeaponMG42::GetPrimaryAttackActivity( void )
{
	Activity actPrim;

	if( IsDeployed() )
	{
		switch ( m_iClip1 )
		{
		case 8:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_8;
			break;
		case 7:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_7;
			break;
		case 6:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_6;
			break;
		case 5:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_5;
			break;
		case 4:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_4;
			break;
		case 3:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_3;
			break;
		case 2:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_2;
			break;
		case 1:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_1;
			break;
		case 0:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED_EMPTY;
			break;
		default:
			actPrim = ACT_VM_PRIMARYATTACK_DEPLOYED;
			break;
		}
	}
	else
	{
		switch ( m_iClip1 )
		{
		case 8:
			actPrim = ACT_VM_PRIMARYATTACK_8;
			break;
		case 7:
			actPrim = ACT_VM_PRIMARYATTACK_7;
			break;
		case 6:
			actPrim = ACT_VM_PRIMARYATTACK_6;
			break;
		case 5:
			actPrim = ACT_VM_PRIMARYATTACK_5;
			break;
		case 4:
			actPrim = ACT_VM_PRIMARYATTACK_4;
			break;
		case 3:
			actPrim = ACT_VM_PRIMARYATTACK_3;
			break;
		case 2:
			actPrim = ACT_VM_PRIMARYATTACK_2;
			break;
		case 1:
			actPrim = ACT_VM_PRIMARYATTACK_1;
			break;
		case 0:
			actPrim = ACT_VM_PRIMARYATTACK_EMPTY;
			break;
		default:
			actPrim = ACT_VM_PRIMARYATTACK;
			break;
		}
	}

	return actPrim;
}

float CWeaponMG42::GetRecoil( void )
{
	CDODPlayer *p = ToDODPlayer( GetPlayerOwner() );

	if( p && p->m_Shared.IsInMGDeploy() )
	{
		return 0.0f;
	}

	return 20;
}

#ifdef CLIENT_DLL

//-----------------------------------------------------------------------------
// This is called after sending this entity's recording state
//-----------------------------------------------------------------------------
void CWeaponMG42::CleanupToolRecordingState( KeyValues *msg )
{
	BaseClass::CleanupToolRecordingState( msg );

	// Generally, this is used to allow the entity to clean up
	// allocated state it put into the message, but here we're going
	// to use it to send particle system messages because we
	// know the smoke has been recorded at this point
	if ( !clienttools->IsInRecordingMode() || !m_pEmitter.IsValid() )
		return;

	// NOTE: Particle system destruction message will be sent by the particle effect itself.
	if ( m_pEmitter->GetToolParticleEffectId() == TOOLPARTICLESYSTEMID_INVALID )
	{
		int nId = m_pEmitter->AllocateToolParticleEffectId();

		KeyValues *msg = new KeyValues( "ParticleSystem_Create" );
		msg->SetString( "name", "CWeaponMG42 smoke" );
		msg->SetInt( "id", nId );
		msg->SetFloat( "time", gpGlobals->curtime );

		KeyValues *pEmitter0 = msg->FindKey( "DmeSpriteEmitter", true );
		pEmitter0->SetInt( "count", 5 );	// particles per second, when duration is < 0
		pEmitter0->SetFloat( "duration", -1 );
		pEmitter0->SetString( "material", "sprites/effects/bazookapuff" );
		pEmitter0->SetInt( "active", 0 );

		KeyValues *pInitializers = pEmitter0->FindKey( "initializers", true );

		KeyValues *pPosition = pInitializers->FindKey( "DmeRandomAttachmentPositionEntityInitializer", true );
		pPosition->SetPtr( "entindex", (void*)entindex() );
 		pPosition->SetInt( "attachmentIndex0", 1 );
 		pPosition->SetInt( "attachmentIndex1", 2 );

		KeyValues *pLifetime = pInitializers->FindKey( "DmeRandomLifetimeInitializer", true );
		pLifetime->SetFloat( "minLifetime", 1.8f );
 		pLifetime->SetFloat( "maxLifetime", 1.8f );

		KeyValues *pVelocity = pInitializers->FindKey( "DmeConstantVelocityInitializer", true );
		pVelocity->SetFloat( "velocityX", 0.0f );
		pVelocity->SetFloat( "velocityY", 0.0f );
		pVelocity->SetFloat( "velocityZ", 12.0f );

		KeyValues *pRoll = pInitializers->FindKey( "DmeRandomRollInitializer", true );
		pRoll->SetFloat( "minRoll", 0.0f );
 		pRoll->SetFloat( "maxRoll", 0.5f );

		KeyValues *pRollSpeed = pInitializers->FindKey( "DmeSplitRandomRollSpeedInitializer", true );
		pRollSpeed->SetFloat( "minRollSpeed", 0.5f );
 		pRollSpeed->SetFloat( "maxRollSpeed", 1.0f );

		KeyValues *pColor = pInitializers->FindKey( "DmeRandomInterpolatedColorInitializer", true );
 		pColor->SetColor( "color1", Color( 200, 200, 200, 255 ) );
 		pColor->SetColor( "color2", Color( 200, 200, 200, 255 ) );

		KeyValues *pAlpha = pInitializers->FindKey( "DmeRandomAlphaInitializer", true );
		pAlpha->SetInt( "minStartAlpha", 60 );
		pAlpha->SetInt( "maxStartAlpha", 60 );
		pAlpha->SetInt( "minEndAlpha", 0 );
		pAlpha->SetInt( "maxEndAlpha", 0 );

		KeyValues *pSize = pInitializers->FindKey( "DmeRandomSizeInitializer", true );
		pSize->SetFloat( "minStartSize", 4 );
		pSize->SetFloat( "maxStartSize", 4 );
		pSize->SetFloat( "minEndSize", 25 );
		pSize->SetFloat( "maxEndSize", 25 );

		KeyValues *pUpdaters = pEmitter0->FindKey( "updaters", true );

		pUpdaters->FindKey( "DmePositionVelocityUpdater", true );
		pUpdaters->FindKey( "DmeRollUpdater", true );
		pUpdaters->FindKey( "DmeAlphaLinearUpdater", true );
		pUpdaters->FindKey( "DmeSizeUpdater", true );

		// create emitters for each emission rate: 5,10,20,30
		KeyValues *pEmitter1 = pEmitter0->MakeCopy();
		pEmitter1->SetInt( "count", 10 );
		msg->AddSubKey( pEmitter1 );

		KeyValues *pEmitter2 = pEmitter0->MakeCopy();
		pEmitter2->SetInt( "count", 20 );
		msg->AddSubKey( pEmitter2 );

		KeyValues *pEmitter3 = pEmitter0->MakeCopy();
		pEmitter3->SetInt( "count", 30 );
		msg->AddSubKey( pEmitter3 );

		// mark only the appropriate emitter active
		bool bHolstered = GetOwner() && GetOwner()->GetActiveWeapon() != this;
		if ( !bHolstered )
		{
			if ( m_iWeaponHeat > 85 )
			{
				pEmitter3->SetInt( "active", 1 );
			}
			else if ( m_iWeaponHeat > 80 )
			{
				pEmitter2->SetInt( "active", 1 );
			}
			else if ( m_iWeaponHeat > 65 )
			{
				pEmitter1->SetInt( "active", 1 );
			}
			else if ( m_iWeaponHeat > 50 )
			{
				pEmitter0->SetInt( "active", 1 );
			}
		}

		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );
		msg->deleteThis();
	}
	else
	{
		int nEmitterIndex = -1;
		bool bHolstered = GetOwner() && GetOwner()->GetActiveWeapon() != this;
		if ( !bHolstered )
		{
			if ( m_iWeaponHeat > 85 )
			{
				nEmitterIndex = 3;
			}
			else if ( m_iWeaponHeat > 80 )
			{
				nEmitterIndex = 2;
			}
			else if ( m_iWeaponHeat > 65 )
			{
				nEmitterIndex = 1;
			}
			else if ( m_iWeaponHeat > 50 )
			{
				nEmitterIndex = 0;
			}
		}

		KeyValues *msg = new KeyValues( "ParticleSystem_ActivateEmitter" );
		msg->SetInt( "id", m_pEmitter->GetToolParticleEffectId() );
		msg->SetFloat( "time", gpGlobals->curtime );

		msg->SetInt( "emitter", 0 );
		msg->SetInt( "active", nEmitterIndex == 0 );
		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

		msg->SetInt( "emitter", 1 );
		msg->SetInt( "active", nEmitterIndex == 1 );
		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

		msg->SetInt( "emitter", 2 );
		msg->SetInt( "active", nEmitterIndex == 2 );
		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

		msg->SetInt( "emitter", 3 );
		msg->SetInt( "active", nEmitterIndex == 3 );
		ToolFramework_PostToolMessage( HTOOLHANDLE_INVALID, msg );

		msg->deleteThis();
	}
}

#endif