/***
*
*	Copyright (c) 1996-2002, 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.
*
****/
#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )

/*

	h_tentacle.cpp - silo of death tentacle monster (half life)

*/

#include	"extdll.h"
#include	"util.h"
#include	"cbase.h"
#include	"monsters.h"
#include	"weapons.h"
#include	"soundent.h"

#define ACT_T_IDLE		1010
#define ACT_T_TAP		1020
#define ACT_T_STRIKE		1030
#define ACT_T_REARIDLE		1040

class CTentacle : public CBaseMonster
{
public:
	CTentacle( void );

	void Spawn();
	void Precache();
	void KeyValue( KeyValueData *pkvd );

	int Save( CSave &save );
	int Restore( CRestore &restore );
	static TYPEDESCRIPTION m_SaveData[];

	// Don't allow the tentacle to go across transitions!!!
	virtual int ObjectCaps( void ) { return CBaseMonster::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }

	void SetObjectCollisionBox( void )
	{
		pev->absmin = pev->origin + Vector( -400, -400, 0 );
		pev->absmax = pev->origin + Vector( 400, 400, 850 );
	}

	void EXPORT Cycle( void );
	void EXPORT CommandUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
	void EXPORT Start( void );
	void EXPORT DieThink( void );

	void EXPORT Test( void );

	void EXPORT HitTouch( CBaseEntity *pOther );

	float HearingSensitivity( void ) { return 2.0; };

	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
	void HandleAnimEvent( MonsterEvent_t *pEvent );
	void Killed( entvars_t *pevAttacker, int iGib );

	MONSTERSTATE GetIdealState( void ) { return MONSTERSTATE_IDLE; };
	int CanPlaySequence( BOOL fDisregardState ) { return TRUE; };

	int Classify( void );

	int Level( float dz );
	int MyLevel( void );
	float MyHeight( void );

	float m_flInitialYaw;
	int m_iGoalAnim;
	int m_iLevel;
	int m_iDir;
	float m_flFramerateAdj;
	float m_flSoundYaw;
	int m_iSoundLevel;
	float m_flSoundTime;
	float m_flSoundRadius;
	int m_iHitDmg;
	float m_flHitTime;

	float m_flTapRadius;

	float m_flNextSong;
	static int g_fFlySound;
	static int g_fSquirmSound;

	float m_flMaxYaw;
	int m_iTapSound;

	Vector m_vecPrevSound;
	float m_flPrevSoundTime;

	static const char *pHitSilo[];
	static const char *pHitDirt[];
	static const char *pHitWater[];
};

int CTentacle::g_fFlySound;
int CTentacle::g_fSquirmSound;

LINK_ENTITY_TO_CLASS( monster_tentacle, CTentacle )

// stike sounds
#define TE_NONE -1
#define TE_SILO 0
#define TE_DIRT 1
#define TE_WATER 2

const char *CTentacle::pHitSilo[] =
{
	"tentacle/te_strike1.wav",
	"tentacle/te_strike2.wav",
};

const char *CTentacle::pHitDirt[] =
{
	"player/pl_dirt1.wav",
	"player/pl_dirt2.wav",
	"player/pl_dirt3.wav",
	"player/pl_dirt4.wav",
};

const char *CTentacle::pHitWater[] =
{
	"player/pl_slosh1.wav",
	"player/pl_slosh2.wav",
	"player/pl_slosh3.wav",
	"player/pl_slosh4.wav",
};

TYPEDESCRIPTION	CTentacle::m_SaveData[] =
{
	DEFINE_FIELD( CTentacle, m_flInitialYaw, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_iGoalAnim, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_iLevel, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_iDir, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_flFramerateAdj, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_flSoundYaw, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_iSoundLevel, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_flSoundTime, FIELD_TIME ),
	DEFINE_FIELD( CTentacle, m_flSoundRadius, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_iHitDmg, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_flHitTime, FIELD_TIME ),
	DEFINE_FIELD( CTentacle, m_flTapRadius, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_flNextSong, FIELD_TIME ),
	DEFINE_FIELD( CTentacle, m_iTapSound, FIELD_INTEGER ),
	DEFINE_FIELD( CTentacle, m_flMaxYaw, FIELD_FLOAT ),
	DEFINE_FIELD( CTentacle, m_vecPrevSound, FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( CTentacle, m_flPrevSoundTime, FIELD_TIME ),
};

IMPLEMENT_SAVERESTORE( CTentacle, CBaseMonster )

// animation sequence aliases 
typedef enum
{
	TENTACLE_ANIM_Pit_Idle,

	TENTACLE_ANIM_rise_to_Temp1,
	TENTACLE_ANIM_Temp1_to_Floor,
	TENTACLE_ANIM_Floor_Idle,
	TENTACLE_ANIM_Floor_Fidget_Pissed,
	TENTACLE_ANIM_Floor_Fidget_SmallRise,
	TENTACLE_ANIM_Floor_Fidget_Wave,
	TENTACLE_ANIM_Floor_Strike,
	TENTACLE_ANIM_Floor_Tap,
	TENTACLE_ANIM_Floor_Rotate,
	TENTACLE_ANIM_Floor_Rear,
	TENTACLE_ANIM_Floor_Rear_Idle,
	TENTACLE_ANIM_Floor_to_Lev1,

	TENTACLE_ANIM_Lev1_Idle,
	TENTACLE_ANIM_Lev1_Fidget_Claw,
	TENTACLE_ANIM_Lev1_Fidget_Shake,
	TENTACLE_ANIM_Lev1_Fidget_Snap,
	TENTACLE_ANIM_Lev1_Strike,
	TENTACLE_ANIM_Lev1_Tap,
	TENTACLE_ANIM_Lev1_Rotate,
	TENTACLE_ANIM_Lev1_Rear,
	TENTACLE_ANIM_Lev1_Rear_Idle,
	TENTACLE_ANIM_Lev1_to_Lev2,

	TENTACLE_ANIM_Lev2_Idle,
	TENTACLE_ANIM_Lev2_Fidget_Shake,
	TENTACLE_ANIM_Lev2_Fidget_Swing,
	TENTACLE_ANIM_Lev2_Fidget_Tut,
	TENTACLE_ANIM_Lev2_Strike,
	TENTACLE_ANIM_Lev2_Tap,
	TENTACLE_ANIM_Lev2_Rotate,
	TENTACLE_ANIM_Lev2_Rear,
	TENTACLE_ANIM_Lev2_Rear_Idle,
	TENTACLE_ANIM_Lev2_to_Lev3,

	TENTACLE_ANIM_Lev3_Idle,
	TENTACLE_ANIM_Lev3_Fidget_Shake,
	TENTACLE_ANIM_Lev3_Fidget_Side,
	TENTACLE_ANIM_Lev3_Fidget_Swipe,
	TENTACLE_ANIM_Lev3_Strike,
	TENTACLE_ANIM_Lev3_Tap,
	TENTACLE_ANIM_Lev3_Rotate,
	TENTACLE_ANIM_Lev3_Rear,
	TENTACLE_ANIM_Lev3_Rear_Idle,

	TENTACLE_ANIM_Lev1_Door_reach,

	TENTACLE_ANIM_Lev3_to_Engine,
	TENTACLE_ANIM_Engine_Idle,
	TENTACLE_ANIM_Engine_Sway,
	TENTACLE_ANIM_Engine_Swat,
	TENTACLE_ANIM_Engine_Bob,
	TENTACLE_ANIM_Engine_Death1,
	TENTACLE_ANIM_Engine_Death2,
	TENTACLE_ANIM_Engine_Death3,

	TENTACLE_ANIM_none
} TENTACLE_ANIM;

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

//
// Tentacle Spawn
//
void CTentacle::Spawn()
{
	Precache();

	pev->solid = SOLID_BBOX;
	pev->movetype = MOVETYPE_FLY;
	pev->effects = 0;
	pev->health = 75;
	pev->sequence = 0;

	SET_MODEL( ENT( pev ), "models/tentacle2.mdl" );
	UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );

	pev->takedamage = DAMAGE_AIM;
	pev->flags |= FL_MONSTER;

	m_bloodColor = BLOOD_COLOR_GREEN;

	SetThink( &CTentacle::Start );
	SetTouch( &CTentacle::HitTouch );
	SetUse( &CTentacle::CommandUse );

	pev->nextthink = gpGlobals->time + 0.2;

	ResetSequenceInfo();
	m_iDir = 1;

	pev->yaw_speed = 18;
	m_flInitialYaw = pev->angles.y;
	pev->ideal_yaw = m_flInitialYaw;

	g_fFlySound = FALSE;
	g_fSquirmSound = FALSE;

	m_iHitDmg = 20;

	if( m_flMaxYaw <= 0 )
		m_flMaxYaw = 65;

	m_MonsterState = MONSTERSTATE_IDLE;

	// SetThink( &Test );
	UTIL_SetOrigin( pev, pev->origin );
}

void CTentacle::Precache()
{
	PRECACHE_MODEL( "models/tentacle2.mdl" );

	PRECACHE_SOUND( "ambience/flies.wav" );
	PRECACHE_SOUND( "ambience/squirm2.wav" );

	PRECACHE_SOUND( "tentacle/te_alert1.wav" );
	PRECACHE_SOUND( "tentacle/te_alert2.wav" );
	PRECACHE_SOUND( "tentacle/te_flies1.wav" );
	PRECACHE_SOUND( "tentacle/te_move1.wav" );
	PRECACHE_SOUND( "tentacle/te_move2.wav" );
	PRECACHE_SOUND( "tentacle/te_roar1.wav" );
	PRECACHE_SOUND( "tentacle/te_roar2.wav" );
	PRECACHE_SOUND( "tentacle/te_search1.wav" );
	PRECACHE_SOUND( "tentacle/te_search2.wav" );
	PRECACHE_SOUND( "tentacle/te_sing1.wav" );
	PRECACHE_SOUND( "tentacle/te_sing2.wav" );
	PRECACHE_SOUND( "tentacle/te_squirm2.wav" );
	PRECACHE_SOUND( "tentacle/te_strike1.wav" );
	PRECACHE_SOUND( "tentacle/te_strike2.wav" );
	PRECACHE_SOUND( "tentacle/te_swing1.wav" );
	PRECACHE_SOUND( "tentacle/te_swing2.wav" );

	PRECACHE_SOUND_ARRAY( pHitSilo );
	PRECACHE_SOUND_ARRAY( pHitDirt );
	PRECACHE_SOUND_ARRAY( pHitWater );
}

CTentacle::CTentacle()
{
	m_flMaxYaw = 65;
	m_iTapSound = 0;
}

void CTentacle::KeyValue( KeyValueData *pkvd )
{
	if( FStrEq( pkvd->szKeyName, "sweeparc" ) )
	{
		m_flMaxYaw = atof( pkvd->szValue ) / 2.0;
		pkvd->fHandled = TRUE;
	}
	else if( FStrEq( pkvd->szKeyName, "sound" ) )
	{
		m_iTapSound = atoi( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else
		CBaseMonster::KeyValue( pkvd );
}

int CTentacle::Level( float dz )
{
	if( dz < 216 )
		return 0;
	if( dz < 408 )
		return 1;
	if( dz < 600 )
		return 2;
	return 3;
}

float CTentacle::MyHeight()
{
	switch( MyLevel() )
	{
	case 1:
		return 256;
	case 2:
		return 448;
	case 3:
		return 640;
	}
	return 0;
}

int CTentacle::MyLevel()
{
	switch( pev->sequence )
	{
	case TENTACLE_ANIM_Pit_Idle: 
		return -1;

	case TENTACLE_ANIM_rise_to_Temp1:
	case TENTACLE_ANIM_Temp1_to_Floor:
	case TENTACLE_ANIM_Floor_to_Lev1:
		return 0;
	case TENTACLE_ANIM_Floor_Idle:
	case TENTACLE_ANIM_Floor_Fidget_Pissed:
	case TENTACLE_ANIM_Floor_Fidget_SmallRise:
	case TENTACLE_ANIM_Floor_Fidget_Wave:
	case TENTACLE_ANIM_Floor_Strike:
	case TENTACLE_ANIM_Floor_Tap:
	case TENTACLE_ANIM_Floor_Rotate:
	case TENTACLE_ANIM_Floor_Rear:
	case TENTACLE_ANIM_Floor_Rear_Idle:
		return 0;
	case TENTACLE_ANIM_Lev1_Idle:
	case TENTACLE_ANIM_Lev1_Fidget_Claw:
	case TENTACLE_ANIM_Lev1_Fidget_Shake:
	case TENTACLE_ANIM_Lev1_Fidget_Snap:
	case TENTACLE_ANIM_Lev1_Strike:
	case TENTACLE_ANIM_Lev1_Tap:
	case TENTACLE_ANIM_Lev1_Rotate:
	case TENTACLE_ANIM_Lev1_Rear:
	case TENTACLE_ANIM_Lev1_Rear_Idle:
		return 1;
	case TENTACLE_ANIM_Lev1_to_Lev2:
		return 1;
	case TENTACLE_ANIM_Lev2_Idle:
	case TENTACLE_ANIM_Lev2_Fidget_Shake:
	case TENTACLE_ANIM_Lev2_Fidget_Swing:
	case TENTACLE_ANIM_Lev2_Fidget_Tut:
	case TENTACLE_ANIM_Lev2_Strike:
	case TENTACLE_ANIM_Lev2_Tap:
	case TENTACLE_ANIM_Lev2_Rotate:
	case TENTACLE_ANIM_Lev2_Rear:
	case TENTACLE_ANIM_Lev2_Rear_Idle:
		return 2;
	case TENTACLE_ANIM_Lev2_to_Lev3:
		return 2;
	case TENTACLE_ANIM_Lev3_Idle:
	case TENTACLE_ANIM_Lev3_Fidget_Shake:
	case TENTACLE_ANIM_Lev3_Fidget_Side:
	case TENTACLE_ANIM_Lev3_Fidget_Swipe:
	case TENTACLE_ANIM_Lev3_Strike:
	case TENTACLE_ANIM_Lev3_Tap:
	case TENTACLE_ANIM_Lev3_Rotate:
	case TENTACLE_ANIM_Lev3_Rear:
	case TENTACLE_ANIM_Lev3_Rear_Idle:
		return 3;
	case TENTACLE_ANIM_Lev1_Door_reach:
		return -1;
	}
	return -1;
}

void CTentacle::Test( void )
{
	pev->sequence = TENTACLE_ANIM_Floor_Strike;
	pev->framerate = 0;
	StudioFrameAdvance();
	pev->nextthink = gpGlobals->time + 0.1;
}

//
// TentacleThink
//
void CTentacle::Cycle( void )
{
	// ALERT( at_console, "%s %.2f %d %d\n", STRING( pev->targetname ), pev->origin.z, m_MonsterState, m_IdealMonsterState );
	pev->nextthink = gpGlobals-> time + 0.1;

	// ALERT( at_console, "%s %d %d %d %f %f\n", STRING( pev->targetname ), pev->sequence, m_iGoalAnim, m_iDir, pev->framerate, pev->health );

	if( m_MonsterState == MONSTERSTATE_SCRIPT || m_IdealMonsterState == MONSTERSTATE_SCRIPT )
	{
		pev->angles.y = m_flInitialYaw;
		pev->ideal_yaw = m_flInitialYaw;	
		ClearConditions( IgnoreConditions() );
		MonsterThink();
		m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
		return;
	}

	DispatchAnimEvents();
	StudioFrameAdvance();

	ChangeYaw( pev->yaw_speed );

	CSound *pSound;

	Listen();

	// Listen will set this if there's something in my sound list
	if( HasConditions( bits_COND_HEAR_SOUND ) )
		pSound = PBestSound();
	else
		pSound = NULL;

	if( pSound )
	{
		Vector vecDir;
		if( gpGlobals->time - m_flPrevSoundTime < 0.5 )
		{
			float dt = gpGlobals->time - m_flPrevSoundTime;
			vecDir = pSound->m_vecOrigin + ( pSound->m_vecOrigin - m_vecPrevSound ) / dt - pev->origin;
		}
		else
		{
			vecDir = pSound->m_vecOrigin - pev->origin;
		}
		m_flPrevSoundTime = gpGlobals->time;
		m_vecPrevSound = pSound->m_vecOrigin;

		m_flSoundYaw = UTIL_VecToYaw( vecDir ) - m_flInitialYaw;
		m_iSoundLevel = Level( vecDir.z );

		if( m_flSoundYaw < -180 )
			m_flSoundYaw += 360;
		if( m_flSoundYaw > 180 )
			m_flSoundYaw -= 360;
#if 0
		// ALERT( at_console, "sound %d %.0f\n", m_iSoundLevel, m_flSoundYaw );
		if( m_flSoundTime < gpGlobals->time )
		{
			// play "I hear new something" sound
			const char *sound;

			switch( RANDOM_LONG( 0, 1 ) )
			{
			case 0:
				sound = "tentacle/te_alert1.wav";
				break;
			case 1:
				sound = "tentacle/te_alert2.wav";
				break;
			}

			// UTIL_EmitAmbientSound( ENT( pev ), pev->origin + Vector( 0, 0, MyHeight() ), sound, 1.0, ATTN_NORM, 0, 100 );
		}
#endif
		m_flSoundTime = gpGlobals->time + RANDOM_FLOAT( 5.0, 10.0 );
	}

	// clip ideal_yaw
	float dy = m_flSoundYaw;
	switch( pev->sequence )
	{
	case TENTACLE_ANIM_Floor_Rear:
	case TENTACLE_ANIM_Floor_Rear_Idle:
	case TENTACLE_ANIM_Lev1_Rear:
	case TENTACLE_ANIM_Lev1_Rear_Idle:
	case TENTACLE_ANIM_Lev2_Rear:
	case TENTACLE_ANIM_Lev2_Rear_Idle:
	case TENTACLE_ANIM_Lev3_Rear:
	case TENTACLE_ANIM_Lev3_Rear_Idle:
		if( dy < 0 && dy > -m_flMaxYaw )
			dy = -m_flMaxYaw;
		if( dy > 0 && dy < m_flMaxYaw )
			dy = m_flMaxYaw;
		break;
	default:
		if( dy < -m_flMaxYaw )
			dy = -m_flMaxYaw;
		if( dy > m_flMaxYaw )
			dy = m_flMaxYaw;
	}
	pev->ideal_yaw = m_flInitialYaw + dy;

	if( m_fSequenceFinished )
	{
		// ALERT( at_console, "%s done %d %d\n", STRING( pev->targetname ), pev->sequence, m_iGoalAnim );
		if( pev->health <= 1 )
		{
			m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
			if( pev->sequence == TENTACLE_ANIM_Pit_Idle )
			{
				pev->health = 75;
			}
		}
		else if( m_flSoundTime > gpGlobals->time )
		{
			if( m_flSoundYaw >= -( m_flMaxYaw + 30 ) && m_flSoundYaw <= ( m_flMaxYaw + 30 ) )
			{
				// strike
				m_iGoalAnim = LookupActivity( ACT_T_STRIKE + m_iSoundLevel );
			}
			else if( m_flSoundYaw >= -m_flMaxYaw * 2 && m_flSoundYaw <= m_flMaxYaw * 2 )
			{
				// tap
				m_iGoalAnim = LookupActivity( ACT_T_TAP + m_iSoundLevel );
			}
			else
			{
				// go into rear idle
				m_iGoalAnim = LookupActivity( ACT_T_REARIDLE + m_iSoundLevel );
			}
		}
		else if( pev->sequence == TENTACLE_ANIM_Pit_Idle )
		{
			// stay in pit until hear noise
			m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
		}
		else if( pev->sequence == m_iGoalAnim )
		{
			if( MyLevel() >= 0 && gpGlobals->time < m_flSoundTime )
			{
				if( RANDOM_LONG( 0, 9 ) < m_flSoundTime - gpGlobals->time )
				{
					// continue stike
					m_iGoalAnim = LookupActivity( ACT_T_STRIKE + m_iSoundLevel );
				}
				else
				{
					// tap
					m_iGoalAnim = LookupActivity( ACT_T_TAP + m_iSoundLevel );
				}
			}
			else if( MyLevel() < 0 )
			{
				m_iGoalAnim = LookupActivity( ACT_T_IDLE + 0 );
			}
			else
			{
				if( m_flNextSong < gpGlobals->time )
				{
					// play "I hear new something" sound
					const char *sound;	

					switch( RANDOM_LONG( 0, 1 ) )
					{
					case 0:
						sound = "tentacle/te_sing1.wav";
						break;
					case 1:
						sound = "tentacle/te_sing2.wav";
						break;
					}

					EMIT_SOUND( ENT( pev ), CHAN_VOICE, sound, 1.0, ATTN_NORM );

					m_flNextSong = gpGlobals->time + RANDOM_FLOAT( 10, 20 );
				}

				if( RANDOM_LONG( 0,15 ) == 0 )
				{
					// idle on new level
					m_iGoalAnim = LookupActivity( ACT_T_IDLE + RANDOM_LONG( 0, 3 ) );
				}
				else if( RANDOM_LONG( 0, 3 ) == 0 )
				{
					// tap
					m_iGoalAnim = LookupActivity( ACT_T_TAP + MyLevel() );
				}
				else
				{
					// idle
					m_iGoalAnim = LookupActivity( ACT_T_IDLE + MyLevel() );
				}
			}
			if( m_flSoundYaw < 0 )
				m_flSoundYaw += RANDOM_FLOAT( 2, 8 );
			else
				m_flSoundYaw -= RANDOM_FLOAT( 2, 8 );
		}

		pev->sequence = FindTransition( pev->sequence, m_iGoalAnim, &m_iDir );

		if( m_iDir > 0 )
		{
			pev->frame = 0;
		}
		else
		{
			m_iDir = -1; // just to safe
			pev->frame = 255;
		}
		ResetSequenceInfo();

		m_flFramerateAdj = RANDOM_FLOAT( -0.2, 0.2 );
		pev->framerate = m_iDir * 1.0 + m_flFramerateAdj;

		switch( pev->sequence )
		{
		case TENTACLE_ANIM_Floor_Tap:
		case TENTACLE_ANIM_Lev1_Tap:
		case TENTACLE_ANIM_Lev2_Tap:
		case TENTACLE_ANIM_Lev3_Tap:
			{
				Vector vecSrc;
				UTIL_MakeVectors( pev->angles );

				TraceResult tr1, tr2;

				vecSrc = pev->origin + Vector( 0, 0, MyHeight() - 4 );
				UTIL_TraceLine( vecSrc, vecSrc + gpGlobals->v_forward * 512, ignore_monsters, ENT( pev ), &tr1 );

				vecSrc = pev->origin + Vector( 0, 0, MyHeight() + 8 );
				UTIL_TraceLine( vecSrc, vecSrc + gpGlobals->v_forward * 512, ignore_monsters, ENT( pev ), &tr2 );

				// ALERT( at_console, "%f %f\n", tr1.flFraction * 512, tr2.flFraction * 512 );

				m_flTapRadius = SetBlending( 0, RANDOM_FLOAT( tr1.flFraction * 512, tr2.flFraction * 512 ) );
			}
			break;
		default:
			m_flTapRadius = 336; // 400 - 64
			break;
		}
		pev->view_ofs.z = MyHeight();
		// ALERT( at_console, "seq %d\n", pev->sequence );
	}

	if( m_flPrevSoundTime + 2.0 > gpGlobals->time )
	{
		// 1.5 normal speed if hears sounds
		pev->framerate = m_iDir * 1.5 + m_flFramerateAdj;
	}
	else if( m_flPrevSoundTime + 5.0 > gpGlobals->time )
	{
		// slowdown to normal
		pev->framerate = m_iDir + m_iDir * ( 5 - ( gpGlobals->time - m_flPrevSoundTime ) ) / 2 + m_flFramerateAdj;
	}
}

void CTentacle::CommandUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
	// ALERT( at_console, "%s triggered %d\n", STRING( pev->targetname ), useType ); 
	switch( useType )
	{
	case USE_OFF:
		pev->takedamage = DAMAGE_NO;
		SetThink( &CTentacle::DieThink );
		m_iGoalAnim = TENTACLE_ANIM_Engine_Death1;
		break;
	case USE_ON:
		if( pActivator )
		{
			// ALERT( at_console, "insert sound\n" );
			CSoundEnt::InsertSound( bits_SOUND_WORLD, pActivator->pev->origin, 1024, 1.0 );
		}
		break;
	case USE_SET:
		break;
	case USE_TOGGLE:
		pev->takedamage = DAMAGE_NO;
		SetThink( &CTentacle::DieThink );
		m_iGoalAnim = TENTACLE_ANIM_Engine_Idle;
		break;
	}
}

void CTentacle::DieThink( void )
{
	pev->nextthink = gpGlobals-> time + 0.1;

	DispatchAnimEvents();
	StudioFrameAdvance();

	ChangeYaw( 24 );

	if( m_fSequenceFinished )
	{
		if( pev->sequence == m_iGoalAnim )
		{
			switch( m_iGoalAnim )
			{
			case TENTACLE_ANIM_Engine_Idle:
			case TENTACLE_ANIM_Engine_Sway:
			case TENTACLE_ANIM_Engine_Swat:
			case TENTACLE_ANIM_Engine_Bob:
				m_iGoalAnim = TENTACLE_ANIM_Engine_Sway + RANDOM_LONG( 0, 2 );
				break;
			case TENTACLE_ANIM_Engine_Death1:
			case TENTACLE_ANIM_Engine_Death2:
			case TENTACLE_ANIM_Engine_Death3:
				UTIL_Remove( this );
				return;
			}
		}

		// ALERT( at_console, "%d : %d => ", pev->sequence, m_iGoalAnim );
		pev->sequence = FindTransition( pev->sequence, m_iGoalAnim, &m_iDir );
		// ALERT( at_console, "%d\n", pev->sequence );

		if( m_iDir > 0 )
		{
			pev->frame = 0;
		}
		else
		{
			pev->frame = 255;
		}
		ResetSequenceInfo();

		float dy;
		switch( pev->sequence )
		{
		case TENTACLE_ANIM_Floor_Rear:
		case TENTACLE_ANIM_Floor_Rear_Idle:
		case TENTACLE_ANIM_Lev1_Rear:
		case TENTACLE_ANIM_Lev1_Rear_Idle:
		case TENTACLE_ANIM_Lev2_Rear:
		case TENTACLE_ANIM_Lev2_Rear_Idle:
		case TENTACLE_ANIM_Lev3_Rear:
		case TENTACLE_ANIM_Lev3_Rear_Idle:
		case TENTACLE_ANIM_Engine_Idle:
		case TENTACLE_ANIM_Engine_Sway:
		case TENTACLE_ANIM_Engine_Swat:
		case TENTACLE_ANIM_Engine_Bob:
		case TENTACLE_ANIM_Engine_Death1:
		case TENTACLE_ANIM_Engine_Death2:
		case TENTACLE_ANIM_Engine_Death3:
			pev->framerate = RANDOM_FLOAT( m_iDir - 0.2, m_iDir + 0.2 );
			dy = 180;
			break;
		default:
			pev->framerate = 1.5;
			dy = 0;
			break;
		}
		pev->ideal_yaw = m_flInitialYaw + dy;
	}
}

void CTentacle::HandleAnimEvent( MonsterEvent_t *pEvent )
{
	const char *sound;

	switch( pEvent->event )
	{
	case 1:
		// bang
		{
			Vector vecSrc, vecAngles;
			GetAttachment( 0, vecSrc, vecAngles );

			// Vector vecSrc = pev->origin + m_flTapRadius * Vector( cos( pev->angles.y * ( 3.14192653 / 180.0 ) ), sin( pev->angles.y * ( M_PI / 180.0 ) ), 0.0 );

			// vecSrc.z += MyHeight();

			switch( m_iTapSound )
			{
			case TE_SILO:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitSilo ), 1.0, ATTN_NORM, 0, 100 );
				break;
			case TE_NONE:
				break;
			case TE_DIRT:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitDirt ), 1.0, ATTN_NORM, 0, 100 );
				break;
			case TE_WATER:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitWater ), 1.0, ATTN_NORM, 0, 100 );
				break;
			}
			gpGlobals->force_retouch++;
		}
		break;
	case 3:
		// start killing swing
		m_iHitDmg = 200;
		// UTIL_EmitAmbientSound( ENT( pev ), pev->origin + Vector( 0, 0, MyHeight() ), "tentacle/te_swing1.wav", 1.0, ATTN_NORM, 0, 100 );
		break;
	case 4:
		// end killing swing
		m_iHitDmg = 25;
		break;
	case 5:
		// just "whoosh" sound
		// UTIL_EmitAmbientSound( ENT( pev ), pev->origin + Vector( 0, 0, MyHeight() ), "tentacle/te_swing2.wav", 1.0, ATTN_NORM, 0, 100 );
		break;
	case 2:
		// tap scrape
	case 6:
		// light tap
		{
			Vector vecSrc = pev->origin + m_flTapRadius * Vector( cos( pev->angles.y * ( M_PI / 180.0 ) ), sin( pev->angles.y * ( M_PI / 180.0 ) ), 0.0 );

			vecSrc.z += MyHeight();

			float flVol = RANDOM_FLOAT( 0.3, 0.5 );

			switch( m_iTapSound )
			{
			case TE_SILO:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitSilo ), flVol, ATTN_NORM, 0, 100 );
				break;
			case TE_NONE:
				break;
			case TE_DIRT:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitDirt ), flVol, ATTN_NORM, 0, 100 );
				break;
			case TE_WATER:
				UTIL_EmitAmbientSound( ENT( pev ), vecSrc, RANDOM_SOUND_ARRAY( pHitWater ), flVol, ATTN_NORM, 0, 100 );
				break;
			}
		}
		break;
	case 7:
		// roar
		switch( RANDOM_LONG( 0, 1 ) )
		{
		case 0:
			sound = "tentacle/te_roar1.wav";
			break;
		case 1:
			sound = "tentacle/te_roar2.wav";
			break;
		}

		UTIL_EmitAmbientSound( ENT( pev ), pev->origin + Vector( 0, 0, MyHeight() ), sound, 1.0, ATTN_NORM, 0, 100 );
		break;
	case 8:
		// search
		switch( RANDOM_LONG( 0, 1 ) )
		{
		case 0:
			sound = "tentacle/te_search1.wav";
			break;
		case 1:
			sound = "tentacle/te_search2.wav";
			break;
		}

		UTIL_EmitAmbientSound(ENT(pev), pev->origin + Vector( 0, 0, MyHeight()), sound, 1.0, ATTN_NORM, 0, 100);
		break;
	case 9:
		// swing
		switch( RANDOM_LONG( 0, 1 ) )
		{
		case 0:
			sound = "tentacle/te_move1.wav";
			break;
		case 1:
			sound = "tentacle/te_move2.wav";
			break;
		}
		UTIL_EmitAmbientSound( ENT( pev ), pev->origin + Vector( 0, 0, MyHeight() ), sound, 1.0, ATTN_NORM, 0, 100 );
		break;
	default:
		CBaseMonster::HandleAnimEvent( pEvent );
	}
}

//
// TentacleStart
//
// void CTentacle::Start( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CTentacle::Start( void )
{
	SetThink( &CTentacle::Cycle );

	if( !g_fFlySound )
	{
		EMIT_SOUND( ENT( pev ), CHAN_BODY, "ambience/flies.wav", 1, ATTN_NORM );
		g_fFlySound = TRUE;
		//pev->nextthink = gpGlobals-> time + 0.1;
	}
	else if( !g_fSquirmSound )
	{
		EMIT_SOUND( ENT( pev ), CHAN_BODY, "ambience/squirm2.wav", 1, ATTN_NORM );
		g_fSquirmSound = TRUE;
	}
	
	pev->nextthink = gpGlobals->time + 0.1;
}

void CTentacle::HitTouch( CBaseEntity *pOther )
{
	TraceResult tr = UTIL_GetGlobalTrace();

	if( pOther->pev->modelindex == pev->modelindex )
		return;

	if( m_flHitTime > gpGlobals->time )
		return;

	// only look at the ones where the player hit me
	if( tr.pHit == NULL || tr.pHit->v.modelindex != pev->modelindex )
		return;

	if( tr.iHitgroup >= 3 )
	{
		pOther->TakeDamage( pev, pev, m_iHitDmg, DMG_CRUSH );
		// ALERT( at_console, "wack %3d : ", m_iHitDmg );
	}
	else if( tr.iHitgroup != 0 )
	{
		pOther->TakeDamage( pev, pev, 20, DMG_CRUSH );
		// ALERT( at_console, "tap  %3d : ", 20 );
	}
	else
	{
		return; // Huh?
	}

	m_flHitTime = gpGlobals->time + 0.5;

	// ALERT( at_console, "%s : ", STRING( tr.pHit->v.classname ) );

	// ALERT( at_console, "%.0f : %s : %d\n", pev->angles.y, STRING( pOther->pev->classname ), tr.iHitgroup );
}

int CTentacle::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
	if( flDamage > pev->health )
	{
		pev->health = 1;
	}
	else
	{
		pev->health -= flDamage;
	}
	return 1;
}

void CTentacle::Killed( entvars_t *pevAttacker, int iGib )
{
	m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
	return;
}

class CTentacleMaw : public CBaseMonster
{
public:
	void Spawn();
	void Precache();
};

LINK_ENTITY_TO_CLASS( monster_tentaclemaw, CTentacleMaw )

//
// Tentacle Spawn
//
void CTentacleMaw::Spawn()
{
	Precache();
	SET_MODEL( ENT( pev ), "models/maw.mdl" );
	UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );

	pev->solid = SOLID_NOT;
	pev->movetype = MOVETYPE_STEP;
	pev->effects = 0;
	pev->health = 75;
	pev->yaw_speed = 8;
	pev->sequence = 0;

	pev->angles.x = 90;
	// ResetSequenceInfo( );
}

void CTentacleMaw::Precache()
{
	PRECACHE_MODEL( "models/maw.mdl" );
}
#endif