halflife-photomode/dlls/houndeye.cpp

/***
*
*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
*	
*	This product contains software technology licensed from Id 
*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
*	All Rights Reserved.
*
*   This source code contains proprietary and confidential information of
*   Valve LLC and its suppliers.  Access to this code is restricted to
*   persons who have executed a written SDK license with Valve.  Any access,
*   use or distribution of this code by or to any unlicensed person is illegal.
*
****/
//=========================================================
// Houndeye - spooky sonic dog.
//=========================================================

#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "schedule.h"
#include "animation.h"
#include "nodes.h"
#include "squadmonster.h"
#include "soundent.h"
#include "game.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_MAX_ATTACK_RADIUS 384
#define HOUNDEYE_SQUAD_BONUS (float)1.1

// Marphy Fact Files Fix - Fix various instances of Houndeye not correctly blinking/closing eyes
#define HOUNDEYE_EYE_FRAMES 3 // 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

//=========================================================
// monster-specific tasks
//=========================================================
enum
{
	TASK_HOUND_CLOSE_EYE = LAST_COMMON_TASK + 1,
	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_COMMON_SCHEDULE + 1,
	SCHED_HOUND_HOP_RETREAT,
	SCHED_HOUND_FAIL,
};

//=========================================================
// 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

class CHoundeye : public CSquadMonster
{
public:
	void Spawn() override;
	void Precache() override;
	int Classify() override;
	void HandleAnimEvent(MonsterEvent_t* pEvent) override;
	void SetYawSpeed() override;
	void WarmUpSound();
	void AlertSound() override;
	void DeathSound() override;
	void WarnSound();
	void PainSound() override;
	void IdleSound() override;
	void StartTask(Task_t* pTask) override;
	void RunTask(Task_t* pTask) override;
	void SonicAttack();
	void PrescheduleThink() override;
	void SetActivity(Activity NewActivity) override;
	void WriteBeamColor();
	bool CheckRangeAttack1(float flDot, float flDist) override;
	bool FValidateHintType(short sHint) override;
	bool FCanActiveIdle() override;
	Schedule_t* GetScheduleOfType(int Type) override;
	Schedule_t* GetSchedule() override;

	bool Save(CSave& save) override;
	bool Restore(CRestore& restore) override;

	CUSTOM_SCHEDULES;
	static TYPEDESCRIPTION m_SaveData[];

	int m_iSpriteTexture;
	bool m_fAsleep;			// some houndeyes sleep in idle mode if this is set, the houndeye is lying down
	bool m_fDontBlink;		// don't try to open/close eye if this bit is set!
	Vector m_vecPackCenter; // the center of the pack. The leader maintains this by averaging the origins of all pack members.
};
LINK_ENTITY_TO_CLASS(monster_houndeye, CHoundeye);

TYPEDESCRIPTION CHoundeye::m_SaveData[] =
	{
		DEFINE_FIELD(CHoundeye, m_iSpriteTexture, FIELD_INTEGER),
		DEFINE_FIELD(CHoundeye, m_fAsleep, FIELD_BOOLEAN),
		DEFINE_FIELD(CHoundeye, m_fDontBlink, FIELD_BOOLEAN),
		DEFINE_FIELD(CHoundeye, m_vecPackCenter, FIELD_POSITION_VECTOR),
};

IMPLEMENT_SAVERESTORE(CHoundeye, CSquadMonster);

//=========================================================
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CHoundeye::Classify()
{
	return CLASS_ALIEN_MONSTER;
}

//=========================================================
//  FValidateHintType
//=========================================================
bool CHoundeye::FValidateHintType(short sHint)
{
	int i;

	static short sHoundHints[] =
		{
			HINT_WORLD_MACHINERY,
			HINT_WORLD_BLINKING_LIGHT,
			HINT_WORLD_HUMAN_BLOOD,
			HINT_WORLD_ALIEN_BLOOD,
		};

	for (i = 0; i < ARRAYSIZE(sHoundHints); i++)
	{
		if (sHoundHints[i] == sHint)
		{
			return true;
		}
	}

	ALERT(at_aiconsole, "Couldn't validate hint type");
	return false;
}


//=========================================================
// FCanActiveIdle
//=========================================================
bool CHoundeye::FCanActiveIdle()
{
	if (InSquad())
	{
		CSquadMonster* pSquadLeader = MySquadLeader();

		for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
		{
			CSquadMonster* pMember = pSquadLeader->MySquadMember(i);

			if (pMember != NULL && pMember != this && pMember->m_iHintNode != NO_NODE)
			{
				// someone else in the group is active idling right now!
				return false;
			}
		}

		return true;
	}

	return true;
}


//=========================================================
// CheckRangeAttack1 - overridden for houndeyes so that they
// try to get within half of their max attack radius before
// attacking, so as to increase their chances of doing damage.
//=========================================================
bool CHoundeye::CheckRangeAttack1(float flDot, float flDist)
{
	if (flDist <= (HOUNDEYE_MAX_ATTACK_RADIUS * 0.5) && flDot >= 0.3)
	{
		return true;
	}
	return false;
}

//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CHoundeye::SetYawSpeed()
{
	int ys;

	ys = 90;

	switch (m_Activity)
	{
	case ACT_CROUCHIDLE: //sleeping!
		ys = 0;
		break;
	case ACT_IDLE:
		ys = 60;
		break;
	case ACT_WALK:
		ys = 90;
		break;
	case ACT_RUN:
		ys = 90;
		break;
	case ACT_TURN_LEFT:
	case ACT_TURN_RIGHT:
		ys = 90;
		break;
	}

	pev->yaw_speed = ys;
}

//=========================================================
// SetActivity
//=========================================================
void CHoundeye::SetActivity(Activity NewActivity)
{
	int iSequence;

	if (NewActivity == m_Activity)
		return;

	if (m_MonsterState == MONSTERSTATE_COMBAT && NewActivity == ACT_IDLE && RANDOM_LONG(0, 1))
	{
		// play pissed idle.
		iSequence = LookupSequence("madidle");

		m_Activity = 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
		m_IdealActivity = m_Activity;

		// Set to the desired anim, or default anim if the desired is not present
		if (iSequence > ACTIVITY_NOT_AVAILABLE)
		{
			pev->sequence = iSequence; // Set to the reset anim (if it's there)
			pev->frame = 0;			   // FIX: frame counter shouldn't be reset when its the same activity as before
			ResetSequenceInfo();
			SetYawSpeed();
		}
	}
	else
	{
		CSquadMonster::SetActivity(NewActivity);
	}
}

//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CHoundeye::HandleAnimEvent(MonsterEvent_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 = g_psv_gravity->value;

		pev->flags &= ~FL_ONGROUND;

		pev->velocity = gpGlobals->v_forward * -200;
		pev->velocity.z += (0.6 * flGravity) * 0.5;

		break;
	}

	case HOUND_AE_THUMP:
		// emit the shockwaves
		SonicAttack();
		break;

	case HOUND_AE_ANGERSOUND1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM);
		break;

	case HOUND_AE_ANGERSOUND2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain1.wav", 1, ATTN_NORM);
		break;

	case HOUND_AE_CLOSE_EYE:
		if (!m_fDontBlink)
		{
			pev->skin = HOUNDEYE_EYE_FRAMES - 1;
		}
		break;

	default:
		CSquadMonster::HandleAnimEvent(pEvent);
		break;
	}
}

//=========================================================
// Spawn
//=========================================================
void CHoundeye::Spawn()
{
	Precache();

	SET_MODEL(ENT(pev), "models/houndeye.mdl");
	UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 36));

	pev->solid = SOLID_SLIDEBOX;
	pev->movetype = MOVETYPE_STEP;
	m_bloodColor = BLOOD_COLOR_YELLOW;
	pev->effects = 0;
	pev->health = gSkillData.houndeyeHealth;
	pev->yaw_speed = 5;	   //!!! should we put this in the monster's changeanim function since turn rates may vary with state/anim?
	m_flFieldOfView = 0.5; // indicates the width of this monster's forward view cone ( as a dotproduct result )
	m_MonsterState = MONSTERSTATE_NONE;
	m_fAsleep = false; // everyone spawns awake
	m_fDontBlink = false;
	m_afCapability |= bits_CAP_SQUAD;

	MonsterInit();
}

//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CHoundeye::Precache()
{
	PRECACHE_MODEL("models/houndeye.mdl");

	PRECACHE_SOUND("houndeye/he_alert1.wav");
	PRECACHE_SOUND("houndeye/he_alert2.wav");
	PRECACHE_SOUND("houndeye/he_alert3.wav");

	PRECACHE_SOUND("houndeye/he_die1.wav");
	PRECACHE_SOUND("houndeye/he_die2.wav");
	PRECACHE_SOUND("houndeye/he_die3.wav");

	PRECACHE_SOUND("houndeye/he_idle1.wav");
	PRECACHE_SOUND("houndeye/he_idle2.wav");
	PRECACHE_SOUND("houndeye/he_idle3.wav");

	PRECACHE_SOUND("houndeye/he_hunt1.wav");
	PRECACHE_SOUND("houndeye/he_hunt2.wav");
	PRECACHE_SOUND("houndeye/he_hunt3.wav");

	PRECACHE_SOUND("houndeye/he_pain1.wav");
	PRECACHE_SOUND("houndeye/he_pain3.wav");
	PRECACHE_SOUND("houndeye/he_pain4.wav");
	PRECACHE_SOUND("houndeye/he_pain5.wav");

	PRECACHE_SOUND("houndeye/he_attack1.wav");
	PRECACHE_SOUND("houndeye/he_attack3.wav");

	PRECACHE_SOUND("houndeye/he_blast1.wav");
	PRECACHE_SOUND("houndeye/he_blast2.wav");
	PRECACHE_SOUND("houndeye/he_blast3.wav");

	m_iSpriteTexture = PRECACHE_MODEL("sprites/shockwave.spr");
}

//=========================================================
// IdleSound
//=========================================================
void CHoundeye::IdleSound()
{
	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_idle1.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_idle2.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_idle3.wav", 1, ATTN_NORM);
		break;
	}
}

//=========================================================
// IdleSound
//=========================================================
void CHoundeye::WarmUpSound()
{
	switch (RANDOM_LONG(0, 1))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_attack1.wav", 0.7, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_attack3.wav", 0.7, ATTN_NORM);
		break;
	}
}

//=========================================================
// WarnSound
//=========================================================
void CHoundeye::WarnSound()
{
	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_hunt1.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_hunt2.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_hunt3.wav", 1, ATTN_NORM);
		break;
	}
}

//=========================================================
// AlertSound
//=========================================================
void CHoundeye::AlertSound()
{

	if (InSquad() && !IsLeader())
	{
		return; // only leader makes ALERT sound.
	}

	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_alert1.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_alert2.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_alert3.wav", 1, ATTN_NORM);
		break;
	}
}

//=========================================================
// DeathSound
//=========================================================
void CHoundeye::DeathSound()
{
	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_die1.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_die2.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_die3.wav", 1, ATTN_NORM);
		break;
	}
}

//=========================================================
// PainSound
//=========================================================
void CHoundeye::PainSound()
{
	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain4.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain5.wav", 1, ATTN_NORM);
		break;
	}
}

//=========================================================
// WriteBeamColor - writes a color vector to the network
// based on the size of the group.
//=========================================================
void CHoundeye::WriteBeamColor()
{
	byte bRed, bGreen, bBlue;

	if (InSquad())
	{
		switch (SquadCount())
		{
		case 2:
			// no case for 0 or 1, cause those are impossible for monsters in Squads.
			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:
			ALERT(at_aiconsole, "Unsupported Houndeye SquadSize!\n");
			bRed = 188;
			bGreen = 220;
			bBlue = 255;
			break;
		}
	}
	else
	{
		// solo houndeye - weakest beam
		bRed = 188;
		bGreen = 220;
		bBlue = 255;
	}

	WRITE_BYTE(bRed);
	WRITE_BYTE(bGreen);
	WRITE_BYTE(bBlue);
}


//=========================================================
// SonicAttack
//=========================================================
void CHoundeye::SonicAttack()
{
	float flAdjustedDamage;
	float flDist;

	switch (RANDOM_LONG(0, 2))
	{
	case 0:
		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast1.wav", 1, ATTN_NORM);
		break;
	case 1:
		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast2.wav", 1, ATTN_NORM);
		break;
	case 2:
		EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast3.wav", 1, ATTN_NORM);
		break;
	}

	// blast circles
	MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
	WRITE_BYTE(TE_BEAMCYLINDER);
	WRITE_COORD(pev->origin.x);
	WRITE_COORD(pev->origin.y);
	WRITE_COORD(pev->origin.z + 16);
	WRITE_COORD(pev->origin.x);
	WRITE_COORD(pev->origin.y);
	WRITE_COORD(pev->origin.z + 16 + HOUNDEYE_MAX_ATTACK_RADIUS / .2); // reach damage radius over .3 seconds
	WRITE_SHORT(m_iSpriteTexture);
	WRITE_BYTE(0);	// startframe
	WRITE_BYTE(0);	// framerate
	WRITE_BYTE(2);	// life
	WRITE_BYTE(16); // width
	WRITE_BYTE(0);	// noise

	WriteBeamColor();

	WRITE_BYTE(255); //brightness
	WRITE_BYTE(0);	 // speed
	MESSAGE_END();

	MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
	WRITE_BYTE(TE_BEAMCYLINDER);
	WRITE_COORD(pev->origin.x);
	WRITE_COORD(pev->origin.y);
	WRITE_COORD(pev->origin.z + 16);
	WRITE_COORD(pev->origin.x);
	WRITE_COORD(pev->origin.y);
	WRITE_COORD(pev->origin.z + 16 + (HOUNDEYE_MAX_ATTACK_RADIUS / 2) / .2); // reach damage radius over .3 seconds
	WRITE_SHORT(m_iSpriteTexture);
	WRITE_BYTE(0);	// startframe
	WRITE_BYTE(0);	// framerate
	WRITE_BYTE(2);	// life
	WRITE_BYTE(16); // width
	WRITE_BYTE(0);	// noise

	WriteBeamColor();

	WRITE_BYTE(255); //brightness
	WRITE_BYTE(0);	 // speed
	MESSAGE_END();


	CBaseEntity* pEntity = NULL;
	// iterate on all entities in the vicinity.
	while ((pEntity = UTIL_FindEntityInSphere(pEntity, pev->origin, HOUNDEYE_MAX_ATTACK_RADIUS)) != NULL)
	{
		if (pEntity->pev->takedamage != DAMAGE_NO)
		{
			if (!FClassnameIs(pEntity->pev, "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 (SquadCount() > 1)
				{
					// squad gets attack bonus.
					flAdjustedDamage = gSkillData.houndeyeDmgBlast + gSkillData.houndeyeDmgBlast * (HOUNDEYE_SQUAD_BONUS * (SquadCount() - 1));
				}
				else
				{
					// solo
					flAdjustedDamage = gSkillData.houndeyeDmgBlast;
				}

				flDist = (pEntity->Center() - pev->origin).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->pev, "func_breakable") && !FClassnameIs(pEntity->pev, "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)
				{
					pEntity->TakeDamage(pev, pev, flAdjustedDamage, DMG_SONIC | DMG_ALWAYSGIB);
				}
			}
		}
	}
}

//=========================================================
// start task
//=========================================================
void CHoundeye::StartTask(Task_t* pTask)
{
	m_iTaskStatus = TASKSTATUS_RUNNING;

	switch (pTask->iTask)
	{
	case TASK_HOUND_FALL_ASLEEP:
	{
		m_fAsleep = true; // signal that hound is lying down (must stand again before doing anything else!)
		m_iTaskStatus = TASKSTATUS_COMPLETE;
		break;
	}
	case TASK_HOUND_WAKE_UP:
	{
		m_fAsleep = false; // signal that hound is standing again
		m_iTaskStatus = TASKSTATUS_COMPLETE;
		break;
	}
	case TASK_HOUND_OPEN_EYE:
	{
		m_fDontBlink = false; // turn blinking back on and that code will automatically open the eye
		m_iTaskStatus = TASKSTATUS_COMPLETE;
		break;
	}
	case TASK_HOUND_CLOSE_EYE:
	{
		pev->skin = 0;
		m_fDontBlink = true; // tell blink code to leave the eye alone.
		break;
	}
	case TASK_HOUND_THREAT_DISPLAY:
	{
		m_IdealActivity = ACT_IDLE_ANGRY;
		break;
	}
	case TASK_HOUND_HOP_BACK:
	{
		m_IdealActivity = ACT_LEAP;
		break;
	}
	case TASK_RANGE_ATTACK1:
	{
		m_IdealActivity = ACT_RANGE_ATTACK1;

		/*
			if ( InSquad() )
			{
				// see if there is a battery to connect to. 
				CSquadMonster *pSquad = m_pSquadLeader;

				while ( pSquad )
				{
					if ( pSquad->m_iMySlot == bits_SLOT_HOUND_BATTERY )
					{
						// draw a beam.
						MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
							WRITE_BYTE( TE_BEAMENTS );
							WRITE_SHORT( ENTINDEX( this->edict() ) );
							WRITE_SHORT( ENTINDEX( pSquad->edict() ) );
							WRITE_SHORT( m_iSpriteTexture );
							WRITE_BYTE( 0 ); // framestart
							WRITE_BYTE( 0 ); // framerate
							WRITE_BYTE( 10 ); // life
							WRITE_BYTE( 40 );  // width
							WRITE_BYTE( 10 );   // noise
							WRITE_BYTE( 0  );   // r, g, b
							WRITE_BYTE( 50 );   // r, g, b
							WRITE_BYTE( 250);   // r, g, b
							WRITE_BYTE( 255 );	// brightness
							WRITE_BYTE( 30 );		// speed
						MESSAGE_END();
						break;
					}

					pSquad = pSquad->m_pSquadNext;
				}
			}
*/

		break;
	}
	case TASK_SPECIAL_ATTACK1:
	{
		m_IdealActivity = ACT_SPECIAL_ATTACK1;
		break;
	}
	case TASK_GUARD:
	{
		m_IdealActivity = ACT_GUARD;
		break;
	}
	default:
	{
		CSquadMonster::StartTask(pTask);
		break;
	}
	}
}

//=========================================================
// RunTask
//=========================================================
void CHoundeye::RunTask(Task_t* pTask)
{
	switch (pTask->iTask)
	{
	case TASK_HOUND_THREAT_DISPLAY:
	{
		MakeIdealYaw(m_vecEnemyLKP);
		ChangeYaw(pev->yaw_speed);

		if (m_fSequenceFinished)
		{
			TaskComplete();
		}

		break;
	}
	case TASK_HOUND_CLOSE_EYE:
	{
		if (pev->skin < HOUNDEYE_EYE_FRAMES - 1)
		{
			pev->skin++;
		}
		break;
	}
	case TASK_HOUND_HOP_BACK:
	{
		if (m_fSequenceFinished)
		{
			TaskComplete();
		}
		break;
	}
	case TASK_SPECIAL_ATTACK1:
	{
		pev->skin = RANDOM_LONG(0, HOUNDEYE_EYE_FRAMES - 1);

		MakeIdealYaw(m_vecEnemyLKP);
		ChangeYaw(pev->yaw_speed);

		float life;
		life = ((255 - pev->frame) / (pev->framerate * m_flFrameRate));
		if (life < 0.1)
			life = 0.1;

		MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
		WRITE_BYTE(TE_IMPLOSION);
		WRITE_COORD(pev->origin.x);
		WRITE_COORD(pev->origin.y);
		WRITE_COORD(pev->origin.z + 16);
		WRITE_BYTE(50 * life + 100);   // radius
		WRITE_BYTE(pev->frame / 25.0); // count
		WRITE_BYTE(life * 10);		   // life
		MESSAGE_END();

		if (m_fSequenceFinished)
		{
			SonicAttack();
			TaskComplete();
		}

		break;
	}
	default:
	{
		CSquadMonster::RunTask(pTask);
		break;
	}
	}
}

//=========================================================
// PrescheduleThink
//=========================================================
void CHoundeye::PrescheduleThink()
{
	// if the hound is mad and is running, make hunt noises.
	if (m_MonsterState == MONSTERSTATE_COMBAT && m_Activity == ACT_RUN && RANDOM_FLOAT(0, 1) < 0.2)
	{
		WarnSound();
	}

	// at random, initiate a blink if not already blinking or sleeping
	if (!m_fDontBlink)
	{
		if ((pev->skin == 0) && RANDOM_LONG(0, 0x7F) == 0)
		{ // start blinking!
			pev->skin = HOUNDEYE_EYE_FRAMES - 1;
		}
		else if (pev->skin != 0)
		{ // already blinking
			pev->skin--;
		}
	}

	// if you are the leader, average the origins of each pack member to get an approximate center.
	if (IsLeader())
	{
		CSquadMonster* pSquadMember;
		int iSquadCount = 0;

		for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
		{
			pSquadMember = MySquadMember(i);

			if (pSquadMember)
			{
				iSquadCount++;
				m_vecPackCenter = m_vecPackCenter + pSquadMember->pev->origin;
			}
		}

		m_vecPackCenter = m_vecPackCenter / iSquadCount;
	}
}

//=========================================================
// AI Schedules Specific to this monster
//=========================================================
// Marphy Fact Files Fix - Fix freeze stutter after leaderlook sequence
Task_t tlHoundGuardPack[] =
	{
		{TASK_STOP_MOVING, (float)0},
		{TASK_PLAY_SEQUENCE, (float)ACT_GUARD},
};

Schedule_t slHoundGuardPack[] =
	{
		{tlHoundGuardPack,
			ARRAYSIZE(tlHoundGuardPack),
			bits_COND_SEE_HATE |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE |
				bits_COND_PROVOKED |
				bits_COND_HEAR_SOUND,

			bits_SOUND_COMBAT | // sound flags
				bits_SOUND_WORLD |
				bits_SOUND_MEAT |
				bits_SOUND_PLAYER,
			"GuardPack"},
};

// primary range attack
Task_t tlHoundYell1[] =
	{
		{TASK_STOP_MOVING, (float)0},
		{TASK_FACE_IDEAL, (float)0},
		{TASK_RANGE_ATTACK1, (float)0},
		{TASK_SET_SCHEDULE, (float)SCHED_HOUND_AGITATED},
};

Task_t tlHoundYell2[] =
	{
		{TASK_STOP_MOVING, (float)0},
		{TASK_FACE_IDEAL, (float)0},
		{TASK_RANGE_ATTACK1, (float)0},
};

Schedule_t slHoundRangeAttack[] =
	{
		{tlHoundYell1,
			ARRAYSIZE(tlHoundYell1),
			bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE,
			0,
			"HoundRangeAttack1"},
		{tlHoundYell2,
			ARRAYSIZE(tlHoundYell2),
			bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE,
			0,
			"HoundRangeAttack2"},
};

// lie down and fall asleep
Task_t tlHoundSleep[] =
	{
		{TASK_STOP_MOVING, (float)0},
		{TASK_SET_ACTIVITY, (float)ACT_IDLE},
		{TASK_WAIT_RANDOM, (float)5},
		{TASK_PLAY_SEQUENCE, (float)ACT_CROUCH},
		{TASK_SET_ACTIVITY, (float)ACT_CROUCHIDLE},
		{TASK_HOUND_FALL_ASLEEP, (float)0},
		{TASK_WAIT_RANDOM, (float)25},
		{TASK_HOUND_CLOSE_EYE, (float)0},
		//{ TASK_WAIT,				(float)10				},
		//{ TASK_WAIT_RANDOM,			(float)10				},
};

Schedule_t slHoundSleep[] =
	{
		{tlHoundSleep,
			ARRAYSIZE(tlHoundSleep),
			bits_COND_HEAR_SOUND |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE |
				bits_COND_NEW_ENEMY,

			bits_SOUND_COMBAT |
				bits_SOUND_PLAYER |
				bits_SOUND_WORLD,
			"Hound Sleep"},
};

// wake and stand up lazily
Task_t tlHoundWakeLazy[] =
	{
		{TASK_STOP_MOVING, (float)0},
		{TASK_HOUND_OPEN_EYE, (float)0},
		{TASK_WAIT_RANDOM, (float)2.5},
		{TASK_PLAY_SEQUENCE, (float)ACT_STAND},
		{TASK_HOUND_WAKE_UP, (float)0},
};

Schedule_t slHoundWakeLazy[] =
	{
		{tlHoundWakeLazy,
			ARRAYSIZE(tlHoundWakeLazy),
			0,
			0,
			"WakeLazy"},
};

// wake and stand up with great urgency!
Task_t tlHoundWakeUrgent[] =
	{
		{TASK_HOUND_OPEN_EYE, (float)0},
		{TASK_PLAY_SEQUENCE, (float)ACT_HOP},
		{TASK_FACE_IDEAL, (float)0},
		{TASK_HOUND_WAKE_UP, (float)0},
};

Schedule_t slHoundWakeUrgent[] =
	{
		{tlHoundWakeUrgent,
			ARRAYSIZE(tlHoundWakeUrgent),
			0,
			0,
			"WakeUrgent"},
};


Task_t tlHoundSpecialAttack1[] =
	{
		{TASK_STOP_MOVING, 0},
		{TASK_FACE_IDEAL, (float)0},
		{TASK_SPECIAL_ATTACK1, (float)0},
		{TASK_PLAY_SEQUENCE, (float)ACT_IDLE_ANGRY},
};

Schedule_t slHoundSpecialAttack1[] =
	{
		{tlHoundSpecialAttack1,
			ARRAYSIZE(tlHoundSpecialAttack1),
			bits_COND_NEW_ENEMY |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE |
				bits_COND_ENEMY_OCCLUDED,

			0,
			"Hound Special Attack1"},
};

Task_t tlHoundAgitated[] =
	{
		{TASK_STOP_MOVING, 0},
		{TASK_HOUND_THREAT_DISPLAY, 0},
};

Schedule_t slHoundAgitated[] =
	{
		{tlHoundAgitated,
			ARRAYSIZE(tlHoundAgitated),
			bits_COND_NEW_ENEMY |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE,
			0,
			"Hound Agitated"},
};

Task_t tlHoundHopRetreat[] =
	{
		{TASK_STOP_MOVING, 0},
		{TASK_HOUND_HOP_BACK, 0},
		{TASK_SET_SCHEDULE, (float)SCHED_TAKE_COVER_FROM_ENEMY},
};

Schedule_t slHoundHopRetreat[] =
	{
		{tlHoundHopRetreat,
			ARRAYSIZE(tlHoundHopRetreat),
			0,
			0,
			"Hound Hop Retreat"},
};

// hound fails in combat with client in the PVS
Task_t tlHoundCombatFailPVS[] =
	{
		{TASK_STOP_MOVING, 0},
		{TASK_HOUND_THREAT_DISPLAY, 0},
		{TASK_WAIT_FACE_ENEMY, (float)1},
};

Schedule_t slHoundCombatFailPVS[] =
	{
		{tlHoundCombatFailPVS,
			ARRAYSIZE(tlHoundCombatFailPVS),
			bits_COND_NEW_ENEMY |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE,
			0,
			"HoundCombatFailPVS"},
};

// hound fails in combat with no client in the PVS. Don't keep peeping!
Task_t tlHoundCombatFailNoPVS[] =
	{
		{TASK_STOP_MOVING, 0},
		{TASK_HOUND_THREAT_DISPLAY, 0},
		{TASK_WAIT_FACE_ENEMY, (float)2},
		{TASK_SET_ACTIVITY, (float)ACT_IDLE},
		{TASK_WAIT_PVS, 0},
};

Schedule_t slHoundCombatFailNoPVS[] =
	{
		{tlHoundCombatFailNoPVS,
			ARRAYSIZE(tlHoundCombatFailNoPVS),
			bits_COND_NEW_ENEMY |
				bits_COND_LIGHT_DAMAGE |
				bits_COND_HEAVY_DAMAGE,
			0,
			"HoundCombatFailNoPVS"},
};

DEFINE_CUSTOM_SCHEDULES(CHoundeye){
	slHoundGuardPack,
	slHoundRangeAttack,
	&slHoundRangeAttack[1],
	slHoundSleep,
	slHoundWakeLazy,
	slHoundWakeUrgent,
	slHoundSpecialAttack1,
	slHoundAgitated,
	slHoundHopRetreat,
	slHoundCombatFailPVS,
	slHoundCombatFailNoPVS,
};

IMPLEMENT_CUSTOM_SCHEDULES(CHoundeye, CSquadMonster);

//=========================================================
// GetScheduleOfType
//=========================================================
Schedule_t* CHoundeye::GetScheduleOfType(int Type)
{
	if (m_fAsleep)
	{
		// if the hound is sleeping, must wake and stand!
		if (HasConditions(bits_COND_HEAR_SOUND))
		{
			CSound* pWakeSound;

			pWakeSound = PBestSound();
			ASSERT(pWakeSound != NULL);
			if (pWakeSound)
			{
				MakeIdealYaw(pWakeSound->m_vecOrigin);

				if (FLSoundVolume(pWakeSound) >= HOUNDEYE_SOUND_STARTLE_VOLUME)
				{
					// awakened by a loud sound
					return &slHoundWakeUrgent[0];
				}
			}
			// sound was not loud enough to scare the bejesus out of houndeye
			return &slHoundWakeLazy[0];
		}
		else if (HasConditions(bits_COND_NEW_ENEMY))
		{
			// get up fast, to fight.
			return &slHoundWakeUrgent[0];
		}

		else
		{
			// hound is waking up on its own
			return &slHoundWakeLazy[0];
		}
	}
	switch (Type)
	{
	case SCHED_IDLE_STAND:
	{
		// we may want to sleep instead of stand!
		if (InSquad() && !IsLeader() && !m_fAsleep && RANDOM_LONG(0, 29) < 1)
		{
			return &slHoundSleep[0];
		}
		// Marphy Fact Files Fix - Restore squad leader leaderlook animation
		if (InSquad() && IsLeader() && !m_fAsleep && RANDOM_LONG(0, 14) < 1)
		{
			return &slHoundGuardPack[0];
		}
		else
		{
			return CSquadMonster::GetScheduleOfType(Type);
		}
	}
	case SCHED_RANGE_ATTACK1:
	{
		return &slHoundRangeAttack[0];
		/*
			if ( InSquad() )
			{
				return &slHoundRangeAttack[ RANDOM_LONG( 0, 1 ) ];
			}

			return &slHoundRangeAttack[ 1 ];
*/
	}
	case SCHED_SPECIAL_ATTACK1:
	{
		return &slHoundSpecialAttack1[0];
	}
	case SCHED_GUARD:
	{
		return &slHoundGuardPack[0];
	}
	case SCHED_HOUND_AGITATED:
	{
		return &slHoundAgitated[0];
	}
	case SCHED_HOUND_HOP_RETREAT:
	{
		return &slHoundHopRetreat[0];
	}
	case SCHED_FAIL:
	{
		if (m_MonsterState == MONSTERSTATE_COMBAT)
		{
			if (!FNullEnt(FIND_CLIENT_IN_PVS(edict())))
			{
				// client in PVS
				return &slHoundCombatFailPVS[0];
			}
			else
			{
				// client has taken off!
				return &slHoundCombatFailNoPVS[0];
			}
		}
		else
		{
			return CSquadMonster::GetScheduleOfType(Type);
		}
	}
	default:
	{
		return CSquadMonster::GetScheduleOfType(Type);
	}
	}
}

//=========================================================
// GetSchedule
//=========================================================
Schedule_t* CHoundeye::GetSchedule()
{
	switch (m_MonsterState)
	{
	case MONSTERSTATE_COMBAT:
	{
		// dead enemy
		if (HasConditions(bits_COND_ENEMY_DEAD))
		{
			// call base class, all code to handle dead enemies is centralized there.
			return CBaseMonster::GetSchedule();
		}

		if (HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
		{
			if (RANDOM_FLOAT(0, 1) <= 0.4)
			{
				TraceResult tr;
				UTIL_MakeVectors(pev->angles);
				UTIL_TraceHull(pev->origin, pev->origin + gpGlobals->v_forward * -128, dont_ignore_monsters, head_hull, ENT(pev), &tr);

				if (tr.flFraction == 1.0)
				{
					// it's clear behind, so the hound will jump
					return GetScheduleOfType(SCHED_HOUND_HOP_RETREAT);
				}
			}

			return GetScheduleOfType(SCHED_TAKE_COVER_FROM_ENEMY);
		}

		if (HasConditions(bits_COND_CAN_RANGE_ATTACK1))
		{
			if (OccupySlot(bits_SLOTS_HOUND_ATTACK))
			{
				return GetScheduleOfType(SCHED_RANGE_ATTACK1);
			}

			return GetScheduleOfType(SCHED_HOUND_AGITATED);
		}
		break;
	}
	}

	return CSquadMonster::GetSchedule();
}