1HEADmaster

1 files changed, 1287 insertions, 0 deletions

diff --git a/game/server/hl1/hl1_npc_houndeye.cpp b/game/server/hl1/hl1_npc_houndeye.cpp
new file mode 100644
index 0000000..10ae189
--- /dev/null
+++ b/game/server/hl1/hl1_npc_houndeye.cpp
@@ -0,0 +1,1287 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Cute hound like Alien.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "game.h"
+#include "ai_default.h"
+#include "ai_schedule.h"
+#include "ai_hull.h"
+#include "ai_navigator.h"
+#include "ai_route.h"
+#include "ai_squad.h"
+#include "ai_squadslot.h"
+#include "ai_hint.h"
+#include "npcevent.h"
+#include "animation.h"
+#include "hl1_npc_houndeye.h"
+#include "gib.h"
+#include "soundent.h"
+#include "ndebugoverlay.h"
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#include "movevars_shared.h"
+
+// houndeye does 20 points of damage spread over a sphere 384 units in diameter, and each additional 
+// squad member increases the BASE damage by 110%, per the spec.
+#define HOUNDEYE_MAX_SQUAD_SIZE			4
+#define	HOUNDEYE_SQUAD_BONUS			(float)1.1
+
+#define HOUNDEYE_EYE_FRAMES 4 // how many different switchable maps for the eye
+
+#define HOUNDEYE_SOUND_STARTLE_VOLUME	128 // how loud a sound has to be to badly scare a sleeping houndeye
+
+#define HOUNDEYE_TOP_MASS	 300.0f
+
+ConVar sk_houndeye_health ( "sk_houndeye_health", "20" );
+ConVar sk_houndeye_dmg_blast ( "sk_houndeye_dmg_blast", "15" );
+
+static int s_iSquadIndex = 0;
+
+//=========================================================
+// Monster's Anim Events Go Here
+//=========================================================
+#define		HOUND_AE_WARN			1
+#define		HOUND_AE_STARTATTACK	2
+#define		HOUND_AE_THUMP			3
+#define		HOUND_AE_ANGERSOUND1	4
+#define		HOUND_AE_ANGERSOUND2	5
+#define		HOUND_AE_HOPBACK		6
+#define		HOUND_AE_CLOSE_EYE		7
+
+BEGIN_DATADESC( CNPC_Houndeye )
+	DEFINE_FIELD( m_iSpriteTexture, FIELD_INTEGER ),
+	DEFINE_FIELD( m_fAsleep, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_fDontBlink, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_vecPackCenter, FIELD_POSITION_VECTOR ),
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS( monster_houndeye, CNPC_Houndeye );
+
+//=========================================================
+// monster-specific tasks
+//=========================================================
+enum
+{
+	TASK_HOUND_CLOSE_EYE = LAST_SHARED_TASK,
+	TASK_HOUND_OPEN_EYE,
+	TASK_HOUND_THREAT_DISPLAY,
+	TASK_HOUND_FALL_ASLEEP,
+	TASK_HOUND_WAKE_UP,
+	TASK_HOUND_HOP_BACK,
+};
+
+//=========================================================
+// monster-specific schedule types
+//=========================================================
+enum
+{
+	SCHED_HOUND_AGITATED = LAST_SHARED_SCHEDULE,
+	SCHED_HOUND_HOP_RETREAT,
+	SCHED_HOUND_YELL1,
+	SCHED_HOUND_YELL2,
+	SCHED_HOUND_RANGEATTACK,
+	SCHED_HOUND_SLEEP,
+	SCHED_HOUND_WAKE_LAZY,
+	SCHED_HOUND_WAKE_URGENT,
+	SCHED_HOUND_SPECIALATTACK,
+	SCHED_HOUND_COMBAT_FAIL_PVS,
+	SCHED_HOUND_COMBAT_FAIL_NOPVS,
+//	SCHED_HOUND_FAIL,
+};
+
+enum HoundEyeSquadSlots
+{	
+	SQUAD_SLOTS_HOUND_ATTACK = LAST_SHARED_SQUADSLOT,
+};
+
+
+//=========================================================
+// Spawn
+//=========================================================
+void CNPC_Houndeye::Spawn()
+{
+	Precache( );
+	
+	SetRenderColor( 255, 255, 255, 255 );
+
+	SetModel( "models/houndeye.mdl" );
+	
+	SetHullType(HULL_TINY);
+	SetHullSizeNormal();
+	
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+	SetMoveType( MOVETYPE_STEP );
+	m_bloodColor		= BLOOD_COLOR_YELLOW;
+	ClearEffects();
+	m_iHealth			= sk_houndeye_health.GetFloat();
+	m_flFieldOfView		= 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
+	m_NPCState			= NPC_STATE_NONE;
+	m_fAsleep			= FALSE; // everyone spawns awake
+	m_fDontBlink		= FALSE;
+	
+	CapabilitiesClear();
+
+	CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_INNATE_RANGE_ATTACK1 );
+	CapabilitiesAdd( bits_CAP_SQUAD);
+
+	NPCInit();
+}
+
+//=========================================================
+// Precache - precaches all resources this monster needs
+//=========================================================
+void CNPC_Houndeye::Precache()
+{
+	PrecacheModel("models/houndeye.mdl");
+
+	m_iSpriteTexture = PrecacheModel( "sprites/shockwave.vmt" );
+
+	PrecacheScriptSound( "HoundEye.Idle" );
+	PrecacheScriptSound( "HoundEye.Warn" );
+	PrecacheScriptSound( "HoundEye.Hunt" );
+	PrecacheScriptSound( "HoundEye.Alert" );
+	PrecacheScriptSound( "HoundEye.Die" );
+	PrecacheScriptSound( "HoundEye.Pain" );
+	PrecacheScriptSound( "HoundEye.Anger1" );
+	PrecacheScriptSound( "HoundEye.Anger2" );
+	PrecacheScriptSound( "HoundEye.Sonic" );
+
+	BaseClass::Precache();
+}	
+
+void CNPC_Houndeye::Event_Killed( const CTakeDamageInfo &info )
+{
+	// Close the eye to make death more obvious
+	m_nSkin = 1;
+	BaseClass::Event_Killed( info );
+}
+
+int CNPC_Houndeye::RangeAttack1Conditions ( float flDot, float flDist )
+{
+	// I'm not allowed to attack if standing in another hound eye 
+	// (note houndeyes allowed to interpenetrate)
+	trace_t tr;
+	UTIL_TraceHull( GetAbsOrigin(), GetAbsOrigin() + Vector(0,0,0.1), 
+					GetHullMins(), GetHullMaxs(),
+					MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &tr );
+	if (tr.startsolid)
+	{
+		CBaseEntity *pEntity = tr.m_pEnt;
+		if (pEntity->Classify() == CLASS_ALIEN_MONSTER)
+		{
+			return( COND_NONE );
+		}
+	}
+
+	// If I'm really close to my enemy allow me to attack if 
+	// I'm facing regardless of next attack time
+	if (flDist < 100 && flDot >= 0.3)
+	{
+		return COND_CAN_RANGE_ATTACK1;
+	}
+	if ( gpGlobals->curtime < m_flNextAttack )
+	{
+		return( COND_NONE );
+	}
+	if (flDist > ( HOUNDEYE_MAX_ATTACK_RADIUS * 0.5 ))
+	{
+		return COND_TOO_FAR_TO_ATTACK;
+	}
+	if (flDot < 0.3)
+	{
+		return COND_NOT_FACING_ATTACK;
+	}
+	return COND_CAN_RANGE_ATTACK1;
+}
+
+//=========================================================
+// IdleSound
+//=========================================================
+void CNPC_Houndeye::IdleSound ( void )
+{
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Idle" );	
+}
+
+//=========================================================
+// IdleSound
+//=========================================================
+void CNPC_Houndeye::WarmUpSound ( void )
+{
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(),"HoundEye.Warn" );	
+}
+
+//=========================================================
+// WarnSound 
+//=========================================================
+void CNPC_Houndeye::WarnSound ( void )
+{
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Hunt" );	
+}
+
+//=========================================================
+// AlertSound 
+//=========================================================
+void CNPC_Houndeye::AlertSound ( void )
+{
+
+	if ( m_pSquad && !m_pSquad->IsLeader( this ) )
+		 return; // only leader makes ALERT sound.
+
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Alert" );
+}
+
+//=========================================================
+// DeathSound 
+//=========================================================
+void CNPC_Houndeye::DeathSound( const CTakeDamageInfo &info )
+{
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Die" );	
+}
+
+//=========================================================
+// PainSound 
+//=========================================================
+void CNPC_Houndeye::PainSound ( const CTakeDamageInfo &info )
+{
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Pain" );	
+}
+
+//=========================================================
+// MaxYawSpeed - allows each sequence to have a different
+// turn rate associated with it.
+//=========================================================
+float CNPC_Houndeye::MaxYawSpeed  ( void )
+{
+	int flYS;
+
+	flYS = 90;
+
+	switch ( GetActivity() )
+	{
+	case ACT_CROUCHIDLE://sleeping!
+		flYS = 0;
+		break;
+	case ACT_IDLE:	
+		flYS = 60;
+		break;
+	case ACT_WALK:
+		flYS = 90;
+		break;
+	case ACT_RUN:	
+		flYS = 90;
+		break;
+	case ACT_TURN_LEFT:
+	case ACT_TURN_RIGHT:
+		flYS = 90;
+		break;
+	}
+
+	return flYS;
+}
+
+//=========================================================
+// Classify - indicates this monster's place in the 
+// relationship table.
+//=========================================================
+Class_T	CNPC_Houndeye::Classify ( void )
+{
+	return CLASS_ALIEN_MONSTER;
+}
+
+//=========================================================
+// HandleAnimEvent - catches the monster-specific messages
+// that occur when tagged animation frames are played.
+//=========================================================
+void CNPC_Houndeye::HandleAnimEvent( animevent_t *pEvent )
+{
+	switch ( pEvent->event )
+	{
+		case HOUND_AE_WARN:
+			// do stuff for this event.
+			WarnSound();
+			break;
+
+		case HOUND_AE_STARTATTACK:
+			WarmUpSound();
+			break;
+
+		case HOUND_AE_HOPBACK:
+			{
+				float flGravity = GetCurrentGravity();
+				Vector v_forward;
+				GetVectors( &v_forward, NULL, NULL );
+
+				SetGroundEntity( NULL );
+
+				Vector vecVel = v_forward * -200;
+				vecVel.z += ( 0.6 * flGravity ) * 0.5;
+				SetAbsVelocity( vecVel );
+
+				break;
+			}
+
+		case HOUND_AE_THUMP:
+			// emit the shockwaves
+			SonicAttack();
+			break;
+
+		case HOUND_AE_ANGERSOUND1:
+			{
+				CPASAttenuationFilter filter( this );
+				EmitSound( filter, entindex(), "HoundEye.Anger1" );	
+			}
+			break;
+
+		case HOUND_AE_ANGERSOUND2:
+			{
+				CPASAttenuationFilter filter2( this );
+				EmitSound( filter2, entindex(), "HoundEye.Anger2" );	
+			}
+			break;
+
+		case HOUND_AE_CLOSE_EYE:
+			if ( !m_fDontBlink )
+			{
+				m_nSkin = HOUNDEYE_EYE_FRAMES - 1;
+			}
+			break;
+
+		default:
+			BaseClass::HandleAnimEvent( pEvent );
+			break;
+	}
+}
+
+//=========================================================
+// SonicAttack
+//=========================================================
+void CNPC_Houndeye::SonicAttack ( void )
+{
+	float		flAdjustedDamage;
+	float		flDist;
+
+	CPASAttenuationFilter filter( this );
+	EmitSound( filter, entindex(), "HoundEye.Sonic");
+
+	CBroadcastRecipientFilter filter2;
+	te->BeamRingPoint( filter2, 0.0, 
+		GetAbsOrigin(),							//origin
+		16,										//start radius
+		HOUNDEYE_MAX_ATTACK_RADIUS,//end radius
+		m_iSpriteTexture,						//texture
+		0,										//halo index
+		0,										//start frame
+		0,										//framerate
+		0.2,									//life
+		24,									//width
+		16,										//spread
+		0,										//amplitude
+		WriteBeamColor().x,						//r
+		WriteBeamColor().y,						//g
+		WriteBeamColor().z,						//b
+		192,									//a
+		0										//speed
+		);
+
+	CBroadcastRecipientFilter filter3;
+	te->BeamRingPoint( filter3, 0.0, 
+		GetAbsOrigin(),									//origin
+		16,												//start radius
+		HOUNDEYE_MAX_ATTACK_RADIUS / 2,											//end radius
+		m_iSpriteTexture,								//texture
+		0,												//halo index
+		0,												//start frame
+		0,												//framerate
+		0.2,											//life
+		24,											//width
+		16,												//spread
+		0,												//amplitude
+		WriteBeamColor().x,								//r
+		WriteBeamColor().y,								//g
+		WriteBeamColor().z,								//b
+		192,											//a
+		0												//speed
+		);
+	
+	CBaseEntity *pEntity = NULL;
+	// iterate on all entities in the vicinity.
+	while ((pEntity = gEntList.FindEntityInSphere( pEntity, GetAbsOrigin(), HOUNDEYE_MAX_ATTACK_RADIUS )) != NULL)
+	{
+		if ( pEntity->m_takedamage  != DAMAGE_NO )
+		{
+			if ( !FClassnameIs(pEntity, "monster_houndeye") )
+			{// houndeyes don't hurt other houndeyes with their attack
+
+				// houndeyes do FULL damage if the ent in question is visible. Half damage otherwise.
+				// This means that you must get out of the houndeye's attack range entirely to avoid damage.
+				// Calculate full damage first
+
+				if ( m_pSquad && m_pSquad->NumMembers() > 1 )
+				{
+					// squad gets attack bonus.
+					flAdjustedDamage = sk_houndeye_dmg_blast.GetFloat() + sk_houndeye_dmg_blast.GetFloat() * ( HOUNDEYE_SQUAD_BONUS * ( m_pSquad->NumMembers() - 1 ) );
+				}
+				else
+				{
+					// solo
+					flAdjustedDamage =sk_houndeye_dmg_blast.GetFloat();
+				}
+
+				flDist = (pEntity->WorldSpaceCenter() - GetAbsOrigin()).Length();
+
+				flAdjustedDamage -= ( flDist / HOUNDEYE_MAX_ATTACK_RADIUS ) * flAdjustedDamage;
+
+				if ( !FVisible( pEntity ) )
+				{
+					if ( pEntity->IsPlayer() )
+					{
+						// if this entity is a client, and is not in full view, inflict half damage. We do this so that players still 
+						// take the residual damage if they don't totally leave the houndeye's effective radius. We restrict it to clients
+						// so that monsters in other parts of the level don't take the damage and get pissed.
+						flAdjustedDamage *= 0.5;
+					}
+					else if ( !FClassnameIs( pEntity, "func_breakable" ) && !FClassnameIs( pEntity, "func_pushable" ) ) 
+					{
+						// do not hurt nonclients through walls, but allow damage to be done to breakables
+						flAdjustedDamage = 0;
+					}
+				}
+
+				//ALERT ( at_aiconsole, "Damage: %f\n", flAdjustedDamage );
+
+				if (flAdjustedDamage > 0 )
+				{
+					CTakeDamageInfo info( this, this, flAdjustedDamage, DMG_SONIC | DMG_ALWAYSGIB );
+					CalculateExplosiveDamageForce( &info, (pEntity->GetAbsOrigin() - GetAbsOrigin()), pEntity->GetAbsOrigin() );
+
+					pEntity->TakeDamage( info );
+
+					if ( (pEntity->GetAbsOrigin() - GetAbsOrigin()).Length2D() <= HOUNDEYE_MAX_ATTACK_RADIUS )
+					{
+						if ( pEntity->GetMoveType() == MOVETYPE_VPHYSICS || (pEntity->VPhysicsGetObject() && !pEntity->IsPlayer()) ) 
+						{
+							IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
+
+							if ( pPhysObject )
+							{
+								float flMass = pPhysObject->GetMass();
+
+								if ( flMass <= HOUNDEYE_TOP_MASS )
+								{
+									// Increase the vertical lift of the force
+									Vector vecForce = info.GetDamageForce();
+									vecForce.z *= 2.0f;
+									info.SetDamageForce( vecForce );
+
+									pEntity->VPhysicsTakeDamage( info );
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//=========================================================
+// WriteBeamColor - writes a color vector to the network 
+// based on the size of the group. 
+//=========================================================
+Vector CNPC_Houndeye::WriteBeamColor ( void )
+{
+	BYTE	bRed, bGreen, bBlue;
+
+	if ( m_pSquad )
+	{
+		switch ( m_pSquad->NumMembers() )
+		{
+		case 1:
+			// solo houndeye - weakest beam
+			bRed	= 188;
+			bGreen	= 220;
+			bBlue	= 255;
+			break;
+		case 2:
+			bRed	= 101;
+			bGreen	= 133;
+			bBlue	= 221;
+			break;
+		case 3:
+			bRed	= 67;
+			bGreen	= 85;
+			bBlue	= 255;
+			break;
+		case 4:
+			bRed	= 62;
+			bGreen	= 33;
+			bBlue	= 211;
+			break;
+		default:
+			Msg ( "Unsupported Houndeye SquadSize!\n" );
+			bRed	= 188;
+			bGreen	= 220;
+			bBlue	= 255;
+			break;
+		}
+	}
+	else
+	{
+		// solo houndeye - weakest beam
+		bRed	= 188;
+		bGreen	= 220;
+		bBlue	= 255;
+	}
+	
+
+	return Vector ( bRed, bGreen, bBlue );
+}
+
+bool CNPC_Houndeye::ShouldGoToIdleState( void )
+{
+	if ( m_pSquad )
+	{
+		AISquadIter_t iter;
+		for (CAI_BaseNPC *pMember = m_pSquad->GetFirstMember( &iter ); pMember; pMember = m_pSquad->GetNextMember( &iter ) )
+		{
+			if ( pMember != this && pMember->GetHintNode() && pMember->GetHintNode()->HintType() != NO_NODE )
+				 return true;
+		}
+
+		return true;
+	}
+
+	return true;
+}
+
+bool CNPC_Houndeye::FValidateHintType ( CAI_Hint *pHint )
+{
+	switch( pHint->HintType() )
+	{
+		case HINT_HL1_WORLD_MACHINERY:
+			return true;
+			break;
+		case HINT_HL1_WORLD_BLINKING_LIGHT:
+			return true;
+			break;
+		case HINT_HL1_WORLD_HUMAN_BLOOD:
+			return true;
+			break;
+		case HINT_HL1_WORLD_ALIEN_BLOOD:
+			return true;
+			break;
+	}
+
+	Msg ( "Couldn't validate hint type" );
+
+	return false;
+}
+
+//=========================================================
+// SetActivity 
+//=========================================================
+void CNPC_Houndeye::SetActivity ( Activity NewActivity )
+{
+	int	iSequence;
+
+	if ( NewActivity == GetActivity() )
+		return;
+
+	if ( m_NPCState == NPC_STATE_COMBAT && NewActivity == ACT_IDLE && random->RandomInt( 0, 1 ) )
+	{
+		// play pissed idle.
+		iSequence = LookupSequence( "madidle" );
+
+		SetActivity( NewActivity ); // Go ahead and set this so it doesn't keep trying when the anim is not present
+	
+		// In case someone calls this with something other than the ideal activity
+		SetIdealActivity( GetActivity() );
+
+		// Set to the desired anim, or default anim if the desired is not present
+		if ( iSequence > ACTIVITY_NOT_AVAILABLE )
+		{
+			SetSequence( iSequence );	// Set to the reset anim (if it's there)
+			SetCycle( 0 );				// FIX: frame counter shouldn't be reset when its the same activity as before
+			ResetSequenceInfo();
+		}
+	}
+	else
+	{
+		BaseClass::SetActivity ( NewActivity );
+	}
+}
+
+//=========================================================
+// start task
+//=========================================================
+void CNPC_Houndeye::StartTask ( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_HOUND_FALL_ASLEEP:
+		{
+			m_fAsleep = TRUE; // signal that hound is lying down (must stand again before doing anything else!)
+			TaskComplete();
+			break;
+		}
+	case TASK_HOUND_WAKE_UP:
+		{
+			m_fAsleep = FALSE; // signal that hound is standing again
+			TaskComplete();
+			break;
+		}
+	case TASK_HOUND_OPEN_EYE:
+		{
+			m_fDontBlink = FALSE; // turn blinking back on and that code will automatically open the eye
+			TaskComplete();
+			break;
+		}
+	case TASK_HOUND_CLOSE_EYE:
+		{
+			m_nSkin = 0;
+			m_fDontBlink = TRUE; // tell blink code to leave the eye alone.
+			break;
+		}
+	case TASK_HOUND_THREAT_DISPLAY:
+		{
+			SetIdealActivity( ACT_IDLE_ANGRY );
+			break;
+		}
+	case TASK_HOUND_HOP_BACK:
+		{
+			SetIdealActivity( ACT_LEAP );
+			break;
+		}
+	case TASK_RANGE_ATTACK1:
+		{
+			SetIdealActivity( ACT_RANGE_ATTACK1 );
+			break;
+		}
+	case TASK_SPECIAL_ATTACK1:
+		{
+			SetIdealActivity( ACT_SPECIAL_ATTACK1 );
+			break;
+		}
+	default: 
+		{
+			BaseClass::StartTask(pTask);
+			break;
+		}
+	}
+}
+
+//=========================================================
+// RunTask 
+//=========================================================
+void CNPC_Houndeye::RunTask ( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+	case TASK_HOUND_THREAT_DISPLAY:
+		{
+			if ( GetEnemy() )
+			{
+				float idealYaw;
+				idealYaw = UTIL_VecToYaw( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() );
+				GetMotor()->SetIdealYawAndUpdate( idealYaw );
+			}
+
+			if ( IsSequenceFinished() )
+			{
+				TaskComplete();
+			}
+			
+			break;
+		}
+	case TASK_HOUND_CLOSE_EYE:
+		{
+			if ( m_nSkin < HOUNDEYE_EYE_FRAMES - 1 )
+				 m_nSkin++;
+			break;
+		}
+	case TASK_HOUND_HOP_BACK:
+		{
+			if ( IsSequenceFinished() )
+			{
+				TaskComplete();
+			}
+			break;
+		}
+	case TASK_SPECIAL_ATTACK1:
+		{
+			m_nSkin = random->RandomInt(0, HOUNDEYE_EYE_FRAMES - 1);
+
+			float idealYaw;
+			idealYaw = UTIL_VecToYaw( GetNavigator()->GetGoalPos() );
+			GetMotor()->SetIdealYawAndUpdate( idealYaw );
+			
+			float life;
+			life = ((255 - GetCycle()) / ( m_flPlaybackRate * m_flPlaybackRate));
+			if (life < 0.1)
+			{
+				life = 0.1;
+			}
+
+		/*	MessageBegin( MSG_PAS, SVC_TEMPENTITY, GetAbsOrigin() );
+				WRITE_BYTE(  TE_IMPLOSION);
+				WRITE_COORD( GetAbsOrigin().x);
+				WRITE_COORD( GetAbsOrigin().y);
+				WRITE_COORD( GetAbsOrigin().z + 16);
+				WRITE_BYTE( 50 * life + 100);  // radius
+				WRITE_BYTE( pev->frame / 25.0 ); // count
+				WRITE_BYTE( life * 10 ); // life
+			MessageEnd();*/
+			
+			if ( IsSequenceFinished() )
+			{
+				SonicAttack(); 
+				TaskComplete();
+			}
+
+			break;
+		}
+	default:
+		{
+			BaseClass::RunTask(pTask);
+			break;
+		}
+	}
+}
+
+//=========================================================
+// PrescheduleThink
+//=========================================================
+void CNPC_Houndeye::PrescheduleThink ( void )
+{
+	BaseClass::PrescheduleThink();
+	
+	// if the hound is mad and is running, make hunt noises.
+	if ( m_NPCState == NPC_STATE_COMBAT && GetActivity() == ACT_RUN && random->RandomFloat( 0, 1 ) < 0.2 )
+	{
+		WarnSound();
+	}
+
+	// at random, initiate a blink if not already blinking or sleeping
+	if ( !m_fDontBlink )
+	{
+		if ( ( m_nSkin == 0 ) && random->RandomInt(0,0x7F) == 0 )
+		{// start blinking!
+			m_nSkin = HOUNDEYE_EYE_FRAMES - 1;
+		}
+		else if ( m_nSkin != 0 )
+		{// already blinking
+			m_nSkin--;
+		}
+	}
+
+	// if you are the leader, average the origins of each pack member to get an approximate center.
+	if ( m_pSquad && m_pSquad->IsLeader( this ) )
+	{
+		int iSquadCount = 0;
+
+		AISquadIter_t iter;
+		for (CAI_BaseNPC *pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) )
+		{
+			iSquadCount++;
+			m_vecPackCenter = m_vecPackCenter + pSquadMember->GetAbsOrigin();
+		}
+
+		m_vecPackCenter = m_vecPackCenter / iSquadCount;
+	}
+}
+
+//=========================================================
+// GetScheduleOfType 
+//=========================================================
+int CNPC_Houndeye::TranslateSchedule( int scheduleType ) 
+{
+	if ( m_fAsleep )
+	{
+		// if the hound is sleeping, must wake and stand!
+		if ( HasCondition( COND_HEAR_DANGER ) ||  HasCondition( COND_HEAR_THUMPER ) || HasCondition( COND_HEAR_COMBAT ) || 
+			 HasCondition( COND_HEAR_WORLD ) || HasCondition( COND_HEAR_PLAYER ) || HasCondition( COND_HEAR_BULLET_IMPACT ) )
+		{
+			CSound *pWakeSound;
+
+			pWakeSound = GetBestSound();
+			ASSERT( pWakeSound != NULL );
+			if ( pWakeSound )
+			{
+				GetMotor()->SetIdealYawToTarget ( pWakeSound->GetSoundOrigin() );
+
+				if ( FLSoundVolume ( pWakeSound ) >= HOUNDEYE_SOUND_STARTLE_VOLUME )
+				{
+					// awakened by a loud sound
+					return SCHED_HOUND_WAKE_URGENT;
+				}
+			}
+			// sound was not loud enough to scare the bejesus out of houndeye
+			return SCHED_HOUND_WAKE_LAZY;
+		}
+		else if ( HasCondition( COND_NEW_ENEMY ) )
+		{
+			// get up fast, to fight.
+			return SCHED_HOUND_WAKE_URGENT;
+		}
+
+		else
+		{
+			// hound is waking up on its own
+			return SCHED_HOUND_WAKE_LAZY;
+		}
+	}
+	switch	( scheduleType )
+	{
+	case SCHED_IDLE_STAND:
+		{
+			// we may want to sleep instead of stand!
+			if ( m_pSquad && !m_pSquad->IsLeader( this ) && !m_fAsleep && random->RandomInt( 0,29 ) < 1 )
+			{
+				return SCHED_HOUND_SLEEP;
+			}
+			else
+			{
+				return BaseClass::TranslateSchedule( scheduleType );
+			}
+		}
+
+	case SCHED_RANGE_ATTACK1:
+		return SCHED_HOUND_RANGEATTACK;
+	case SCHED_SPECIAL_ATTACK1:
+		return SCHED_HOUND_SPECIALATTACK;
+
+	case SCHED_FAIL:
+		{
+			if ( m_NPCState == NPC_STATE_COMBAT )
+			{
+				if ( !FNullEnt( UTIL_FindClientInPVS( edict() ) ) )
+				{
+					// client in PVS
+					return SCHED_HOUND_COMBAT_FAIL_PVS;
+				}
+				else
+				{
+					// client has taken off! 
+					return SCHED_HOUND_COMBAT_FAIL_NOPVS;
+				}
+			}
+			else
+			{
+				return BaseClass::TranslateSchedule ( scheduleType );
+			}
+		}
+	default:
+		{
+			return BaseClass::TranslateSchedule ( scheduleType );
+		}
+	}
+}
+
+int CNPC_Houndeye::SelectSchedule( void )
+{
+	switch	( m_NPCState )
+	{
+	case NPC_STATE_COMBAT:
+		{
+// dead enemy
+			if ( HasCondition( COND_ENEMY_DEAD ) )
+			{
+				// call base class, all code to handle dead enemies is centralized there.
+				return BaseClass::SelectSchedule();
+			}
+
+			if ( HasCondition( COND_LIGHT_DAMAGE ) || HasCondition( COND_HEAVY_DAMAGE ) )
+			{
+				if ( random->RandomFloat( 0 , 1 ) <= 0.4 )
+				{
+					trace_t trace;
+					Vector v_forward;
+					GetVectors( &v_forward, NULL, NULL );
+					UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin() + v_forward * -128, MASK_SOLID, &trace );
+					
+					if ( trace.fraction == 1.0 )
+					{
+						// it's clear behind, so the hound will jump
+						return SCHED_HOUND_HOP_RETREAT;
+					}
+				}
+
+				return SCHED_TAKE_COVER_FROM_ENEMY;
+			}
+
+			if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )
+			{
+			// don't constraint attacks based on squad slots, just let em all go for it
+//				if ( OccupyStrategySlot ( SQUAD_SLOTS_HOUND_ATTACK ) )
+				return SCHED_RANGE_ATTACK1;
+			}
+			break;
+		}
+	}
+
+	return BaseClass::SelectSchedule();
+}
+
+
+//=========================================================
+// FLSoundVolume - subtracts the volume of the given sound
+// from the distance the sound source is from the caller, 
+// and returns that value, which is considered to be the 'local' 
+// volume of the sound. 
+//=========================================================
+float CNPC_Houndeye::FLSoundVolume( CSound *pSound )
+{
+	return ( pSound->Volume() - ( ( pSound->GetSoundOrigin() - GetAbsOrigin() ).Length() ) );
+}
+
+
+//=========================================================
+//
+// SquadRecruit(), get some monsters of my classification and
+// link them as a group.  returns the group size
+//
+//=========================================================
+int CNPC_Houndeye::SquadRecruit( int searchRadius, int maxMembers )
+{
+	int squadCount;
+	int iMyClass = Classify();// cache this monster's class
+
+	if ( maxMembers < 2 )
+		return 0;
+
+	// I am my own leader
+	squadCount = 1;
+
+	CBaseEntity *pEntity = NULL;
+
+	if ( m_SquadName != NULL_STRING )
+	{
+		// I have a netname, so unconditionally recruit everyone else with that name.
+		pEntity = gEntList.FindEntityByClassname( pEntity, "monster_houndeye" );
+
+		while ( pEntity && squadCount < maxMembers )
+		{
+			CNPC_Houndeye *pRecruit = (CNPC_Houndeye*)pEntity->MyNPCPointer();
+
+			if ( pRecruit )
+			{
+				if ( !pRecruit->m_pSquad && pRecruit->Classify() == iMyClass && pRecruit != this )
+				{
+					// minimum protection here against user error.in worldcraft. 
+					if ( pRecruit->m_SquadName != NULL_STRING && FStrEq( STRING( m_SquadName ), STRING( pRecruit->m_SquadName ) ) )
+					{
+						pRecruit->InitSquad();
+						squadCount++;
+					}
+				}
+			}
+
+			pEntity = gEntList.FindEntityByClassname( pEntity, "monster_houndeye" );
+		}
+
+		return squadCount;
+	}
+	else
+	{
+		char szSquadName[64];
+		Q_snprintf( szSquadName, sizeof( szSquadName ), "squad%d\n", s_iSquadIndex );
+
+		m_SquadName = MAKE_STRING( szSquadName );
+
+		while ( ( pEntity = gEntList.FindEntityInSphere( pEntity, GetAbsOrigin(), searchRadius ) ) != NULL && squadCount < maxMembers )
+		{
+			if ( !FClassnameIs ( pEntity, "monster_houndeye" ) )
+				continue;
+
+			CNPC_Houndeye *pRecruit = (CNPC_Houndeye*)pEntity->MyNPCPointer();
+
+			if ( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_hCine )
+			{
+				// Can we recruit this guy?
+				if ( !pRecruit->m_pSquad && pRecruit->Classify() == iMyClass &&
+					( (iMyClass != CLASS_ALIEN_MONSTER) || FClassnameIs( this, pRecruit->GetClassname() ) ) &&
+					!pRecruit->m_SquadName )
+				{
+					trace_t tr;
+					UTIL_TraceLine( GetAbsOrigin() + GetViewOffset(), pRecruit->GetAbsOrigin() + GetViewOffset(), MASK_NPCSOLID_BRUSHONLY, pRecruit, COLLISION_GROUP_NONE, &tr );// try to hit recruit with a traceline.
+
+					if ( tr.fraction == 1.0 )
+					{
+						//We're ready to recruit people, so start a squad if I don't have one.
+						if ( !m_pSquad )
+						{
+							InitSquad();
+						}
+
+						pRecruit->m_SquadName = m_SquadName;
+
+						pRecruit->CapabilitiesAdd ( bits_CAP_SQUAD );
+						pRecruit->InitSquad();
+
+						squadCount++;
+					}
+				}
+			}
+		}
+
+		if ( squadCount > 1 )
+		{
+			s_iSquadIndex++;
+		}
+	}
+
+	return squadCount;
+}
+
+
+
+void CNPC_Houndeye::StartNPC ( void )
+{
+	if ( !m_pSquad )
+	{
+		if ( m_SquadName != NULL_STRING )
+		{
+			BaseClass::StartNPC();
+			return;
+		}
+		else
+		{
+			int iSquadSize = SquadRecruit( 1024, 4 );
+
+			if ( iSquadSize )
+			{
+				Msg ( "Squad of %d %s formed\n", iSquadSize, GetClassname() );
+			}
+		}
+	}
+
+	BaseClass::StartNPC();
+}
+
+
+
+//------------------------------------------------------------------------------
+//
+// Schedules
+//
+//------------------------------------------------------------------------------
+
+AI_BEGIN_CUSTOM_NPC( monster_houndeye, CNPC_Houndeye )
+
+	DECLARE_TASK ( TASK_HOUND_CLOSE_EYE )
+	DECLARE_TASK ( TASK_HOUND_OPEN_EYE )
+	DECLARE_TASK ( TASK_HOUND_THREAT_DISPLAY )
+	DECLARE_TASK ( TASK_HOUND_FALL_ASLEEP )
+	DECLARE_TASK ( TASK_HOUND_WAKE_UP )
+	DECLARE_TASK ( TASK_HOUND_HOP_BACK )
+
+	//=========================================================
+	// > SCHED_HOUND_RANGEATTACK
+	//=========================================================
+	DEFINE_SCHEDULE
+		(
+		SCHED_HOUND_RANGEATTACK,
+
+		"	Tasks"
+		"		TASK_SET_SCHEDULE			SCHEDULE:SCHED_HOUND_YELL1"
+		"	"
+		"	Interrupts"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+		)
+
+	//=========================================================
+	// > SCHED_HOUND_AGITATED
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_AGITATED,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_HOUND_THREAT_DISPLAY	0"
+		"	"
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_HEAVY_DAMAGE"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_HOP_RETREAT
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_HOP_RETREAT,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_HOUND_HOP_BACK			0"
+		"		TASK_SET_SCHEDULE			SCHEDULE:SCHED_TAKE_COVER_FROM_ENEMY"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_YELL1
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_YELL1,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_FACE_IDEAL				0"
+		"		TASK_RANGE_ATTACK1			0"
+		"		TASK_SET_SCHEDULE			SCHEDULE:SCHED_HOUND_AGITATED"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_YELL2
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_YELL2,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_FACE_IDEAL				0"
+		"		TASK_RANGE_ATTACK1			0"
+		"	"
+		"	Interrupts"
+	)
+
+
+	//=========================================================
+	// > SCHED_HOUND_SLEEP
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_SLEEP,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_SET_ACTIVITY			ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT_RANDOM			5"
+		"		TASK_PLAY_SEQUENCE			ACTIVITY:ACT_CROUCH"
+		"		TASK_SET_ACTIVITY			ACTIVITY:ACT_CROUCHIDLE"
+		"		TASK_HOUND_FALL_ASLEEP		0"
+		"		TASK_WAIT_RANDOM			25"
+			"	TASK_HOUND_CLOSE_EYE		0"
+		"	"
+		"	Interrupts"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+		"		COND_NEW_ENEMY"
+		"		COND_HEAR_COMBAT"
+		"		COND_HEAR_DANGER"
+		"		COND_HEAR_PLAYER"
+		"		COND_HEAR_WORLD"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_WAKE_LAZY
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_WAKE_LAZY,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_HOUND_OPEN_EYE			0"
+		"		TASK_WAIT_RANDOM			2.5"
+		"		TASK_PLAY_SEQUENCE			ACT_STAND"
+		"		TASK_HOUND_WAKE_UP			0"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_WAKE_URGENT
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_WAKE_URGENT,
+
+		"	Tasks"
+		"		TASK_HOUND_OPEN_EYE			0"
+		"		TASK_PLAY_SEQUENCE			ACT_HOP"
+		"		TASK_FACE_IDEAL				0"
+		"		TASK_HOUND_WAKE_UP			0"
+		"	"
+		"	Interrupts"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_SPECIALATTACK
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_SPECIALATTACK,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_FACE_IDEAL				0"
+		"		TASK_SPECIAL_ATTACK1		0"
+		"		TASK_PLAY_SEQUENCE			ACTIVITY:ACT_IDLE_ANGRY"
+		"	"
+		"	Interrupts"
+		"		"
+		"		COND_NEW_ENEMY"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+		"		COND_ENEMY_OCCLUDED"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_COMBAT_FAIL_PVS
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_COMBAT_FAIL_PVS,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_HOUND_THREAT_DISPLAY	0"
+		"		TASK_WAIT_FACE_ENEMY		1"
+		"	"
+		"	Interrupts"
+		"		"
+		"		COND_NEW_ENEMY"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+	)
+
+	//=========================================================
+	// > SCHED_HOUND_COMBAT_FAIL_NOPVS
+	//=========================================================
+	DEFINE_SCHEDULE
+	(
+		SCHED_HOUND_COMBAT_FAIL_NOPVS,
+
+		"	Tasks"
+		"		TASK_STOP_MOVING			0"
+		"		TASK_HOUND_THREAT_DISPLAY	0"
+		"		TASK_WAIT_FACE_ENEMY		1"
+		"		TASK_SET_ACTIVITY			ACTIVITY:ACT_IDLE"
+		"		TASK_WAIT_PVS				0"
+		"	"
+		"	Interrupts"
+		"		COND_NEW_ENEMY"
+		"		COND_LIGHT_DAMAGE"
+		"		COND_HEAVY_DAMAGE"
+	)
+
+AI_END_CUSTOM_NPC()