#include	"cbase.h"
#include	"AI_Default.h"
#include	"AI_Task.h"
#include	"AI_Schedule.h"
#include	"AI_Node.h"
#include	"AI_Hull.h"
#include	"AI_Hint.h"
#include	"AI_Route.h"
#include	"soundent.h"
#include	"game.h"
#include	"NPCEvent.h"
#include	"EntityList.h"
#include	"activitylist.h"
#include	"animation.h"
#include	"basecombatweapon.h"
#include	"IEffects.h"
#include	"vstdlib/random.h"
#include	"engine/IEngineSound.h"
#include	"ammodef.h"
#include	"hl1_ai_basenpc.h"
#include	"AI_Senses.h"

// Animation events
#define LEECH_AE_ATTACK		1
#define LEECH_AE_FLOP		2

//#define DEBUG_BEAMS 0

ConVar sk_leech_health( "sk_leech_health", "2" );
ConVar sk_leech_dmg_bite( "sk_leech_dmg_bite", "2" );

// Movement constants

#define		LEECH_ACCELERATE		10
#define		LEECH_CHECK_DIST		45
#define		LEECH_SWIM_SPEED		50
#define		LEECH_SWIM_ACCEL		80
#define		LEECH_SWIM_DECEL		10
#define		LEECH_TURN_RATE			90
#define		LEECH_SIZEX				10
#define		LEECH_FRAMETIME			0.1

class CNPC_Leech : public CHL1BaseNPC
{
	DECLARE_CLASS( CNPC_Leech, CHL1BaseNPC );
public:

	DECLARE_DATADESC();
	
	void Spawn( void );
	void Precache( void );

	static const char *pAttackSounds[];
	static const char *pAlertSounds[];

	void SwimThink( void );
	void DeadThink( void );

	void SwitchLeechState( void );
	float ObstacleDistance( CBaseEntity *pTarget );
	void UpdateMotion( void );

	void RecalculateWaterlevel( void );
	void Touch( CBaseEntity *pOther );

	void SetObjectCollisionBox( void )
	{
		SetAbsMins( GetLocalOrigin() + Vector(-8,-8,0) );
		SetAbsMaxs( GetLocalOrigin() + Vector(8,8,2) );
	}

	Disposition_t IRelationType(CBaseEntity *pTarget);

	void HandleAnimEvent( animevent_t *pEvent );

	void AttackSound( void );
	void AlertSound( void );

	void Activate( void );

	Class_T	Classify( void ) { return CLASS_INSECT; };

	void Event_Killed( const CTakeDamageInfo &info );


	bool ShouldGib(	const CTakeDamageInfo &info );

	
/*	// Base entity functions
	void Killed( entvars_t *pevAttacker, int iGib );
	int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
*/

private:
	// UNDONE: Remove unused boid vars, do group behavior
	float	m_flTurning;// is this boid turning?
	bool	m_fPathBlocked;// TRUE if there is an obstacle ahead
	float	m_flAccelerate;
	float	m_obstacle;
	float	m_top;
	float	m_bottom;
	float	m_height;
	float	m_waterTime;
	float	m_sideTime;		// Timer to randomly check clearance on sides
	float	m_zTime;
	float	m_stateTime;
	float	m_attackSoundTime;
	Vector  m_oldOrigin;
};

LINK_ENTITY_TO_CLASS( monster_leech, CNPC_Leech );

BEGIN_DATADESC( CNPC_Leech )
	DEFINE_FIELD( CNPC_Leech, m_flTurning, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_fPathBlocked, FIELD_BOOLEAN ),
	DEFINE_FIELD( CNPC_Leech, m_flAccelerate, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_obstacle, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_top, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_bottom, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_height, FIELD_FLOAT ),
	DEFINE_FIELD( CNPC_Leech, m_waterTime, FIELD_TIME ),
	DEFINE_FIELD( CNPC_Leech, m_sideTime, FIELD_TIME ),
	DEFINE_FIELD( CNPC_Leech, m_zTime, FIELD_TIME ),
	DEFINE_FIELD( CNPC_Leech, m_stateTime, FIELD_TIME ),
	DEFINE_FIELD( CNPC_Leech, m_attackSoundTime, FIELD_TIME ),
	DEFINE_FIELD( CNPC_Leech, m_oldOrigin, FIELD_VECTOR ),

	DEFINE_THINKFUNC( CNPC_Leech, SwimThink ),
	DEFINE_THINKFUNC( CNPC_Leech, DeadThink ),
END_DATADESC()

const char *CNPC_Leech::pAttackSounds[] =
{
	"leech/leech_bite1.wav",
	"leech/leech_bite2.wav",
	"leech/leech_bite3.wav",
};

const char *CNPC_Leech::pAlertSounds[] =
{
	"leech/leech_alert1.wav",
	"leech/leech_alert2.wav",
};

bool CNPC_Leech::ShouldGib(	const CTakeDamageInfo &info )
{
	return false;
}

void CNPC_Leech::Spawn( void )
{
	Precache();
	SetModel( "models/leech.mdl" );

	SetHullType(HULL_TINY_CENTERED); 
	SetHullSizeNormal();

	UTIL_SetSize( this, Vector(-1,-1,0), Vector(1,1,2));
	// Don't push the minz down too much or the water check will fail because this entity is really point-sized
	SetSolid( SOLID_BBOX );
	AddSolidFlags( FSOLID_NOT_STANDABLE );
	SetMoveType( MOVETYPE_FLY );
	AddFlag( FL_SWIM );
	m_iHealth	= sk_leech_health.GetInt();

	m_flFieldOfView		= -0.5;	// 180 degree FOV
	SetDistLook( 750 );
	NPCInit();
	SetThink( &CNPC_Leech::SwimThink );
	SetUse( NULL );
	SetTouch( NULL );
	SetViewOffset( vec3_origin );

	m_flTurning = 0;
	m_fPathBlocked = FALSE;
	SetActivity( ACT_SWIM );
	SetState( NPC_STATE_IDLE );
	m_stateTime = gpGlobals->curtime + random->RandomFloat( 1, 5 );

	SetRenderColor( 255, 255, 255, 255 );

	m_bloodColor		= DONT_BLEED;
	SetCollisionGroup( COLLISION_GROUP_DEBRIS );
}

void CNPC_Leech::Activate( void )
{
	RecalculateWaterlevel();

	BaseClass::Activate();
}

void CNPC_Leech::DeadThink( void )
{
	if ( IsSequenceFinished() )
	{
		if ( GetActivity() == ACT_DIEFORWARD )
		{
			SetThink( NULL );
			StopAnimation();
			return;
		}
		else if ( GetFlags() & FL_ONGROUND )
		{
			AddSolidFlags( FSOLID_NOT_SOLID );
			SetActivity( ACT_DIEFORWARD );
		}
	}
	StudioFrameAdvance();
	SetNextThink( gpGlobals->curtime + 0.1 );

	// Apply damage velocity, but keep out of the walls
	if ( GetAbsVelocity().x != 0 || GetAbsVelocity().y != 0 )
	{
		trace_t tr;

		// Look 0.5 seconds ahead
		UTIL_TraceLine( GetLocalOrigin(), GetLocalOrigin() + GetAbsVelocity() * 0.5, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
		if (tr.fraction != 1.0)
		{
			Vector vVelocity = GetAbsVelocity();

			vVelocity.x = 0;
			vVelocity.y = 0;

			SetAbsVelocity( vVelocity );
		}
	}
}


Disposition_t CNPC_Leech::IRelationType( CBaseEntity *pTarget )
{
	if ( pTarget->IsPlayer() )
		return D_HT;
	
	return BaseClass::IRelationType( pTarget );
}

void CNPC_Leech::Touch( CBaseEntity *pOther )
{
	if ( !pOther->IsPlayer() )
		 return;

	if ( pOther == GetTouchTrace().m_pEnt )
	{
		if ( pOther->GetAbsVelocity() == vec3_origin )
			 return;

		SetBaseVelocity( pOther->GetAbsVelocity() );
		AddFlag( FL_BASEVELOCITY );
	}
}

void CNPC_Leech::HandleAnimEvent( animevent_t *pEvent )
{
	CBaseEntity *pEnemy = GetEnemy();

	switch( pEvent->event )
	{
	case LEECH_AE_FLOP:
		// Play flop sound
		break;

	case LEECH_AE_ATTACK:
		AttackSound();
		
		if ( pEnemy != NULL )
		{
			Vector dir, face;
	
			AngleVectors( GetAbsAngles(), &face );
			
			face.z = 0;
			dir = (pEnemy->GetLocalOrigin() - GetLocalOrigin() );
			dir.z = 0;
			
			VectorNormalize( dir );
			VectorNormalize( face );
						
			if ( DotProduct(dir, face) > 0.9 )		// Only take damage if the leech is facing the prey
			{
				CTakeDamageInfo info( this, this, sk_leech_dmg_bite.GetInt(), DMG_SLASH );
				CalculateMeleeDamageForce( &info, dir, pEnemy->GetAbsOrigin() );
				pEnemy->TakeDamage( info );
			}
		}
		m_stateTime -= 2;
		break;
	

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


void CNPC_Leech::Precache( void )
{
	engine->PrecacheModel("models/leech.mdl");

    PRECACHE_SOUND_ARRAY(pAttackSounds);
	PRECACHE_SOUND_ARRAY(pAlertSounds);
}


void CNPC_Leech::AttackSound( void )
{
	if ( gpGlobals->curtime > m_attackSoundTime )
	{
		CPASAttenuationFilter filter( this );

		enginesound->EmitSound(filter, entindex(), CHAN_VOICE, pAttackSounds[ random->RandomInt(0,ARRAYSIZE(pAttackSounds)-1) ], 1.0, ATTN_NORM, 0, PITCH_NORM );
		m_attackSoundTime = gpGlobals->curtime + 0.5;
	}
}


void CNPC_Leech::AlertSound( void )
{
	CPASAttenuationFilter filter( this );

	enginesound->EmitSound(filter, entindex(), CHAN_VOICE, pAlertSounds[ random->RandomInt(0,ARRAYSIZE(pAlertSounds)-1) ], 1.0, ATTN_NORM * 0.5, 0, PITCH_NORM );
}

void CNPC_Leech::SwitchLeechState( void )
{
	m_stateTime = gpGlobals->curtime + random->RandomFloat( 3, 6 );
	if ( m_NPCState == NPC_STATE_COMBAT )
	{
		SetEnemy ( NULL );
		SetState( NPC_STATE_IDLE );
		// We may be up against the player, so redo the side checks
		m_sideTime = 0;
	}
	else
	{
		GetSenses()->Look( GetSenses()->GetDistLook() );
		CBaseEntity *pEnemy = BestEnemy();
		if ( pEnemy && pEnemy->GetWaterLevel() != 0 )
		{
			SetEnemy ( pEnemy );
			SetState( NPC_STATE_COMBAT );
			m_stateTime = gpGlobals->curtime + random->RandomFloat( 18, 25 );
			AlertSound();
		}
	}
}

void CNPC_Leech::RecalculateWaterlevel( void )
{
	// Calculate boundaries
	Vector vecTest = GetLocalOrigin() - Vector(0,0,400);

	trace_t tr;

	UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
	
	if ( tr.fraction != 1.0 )
		m_bottom = tr.endpos.z + 1;
	else
		m_bottom = vecTest.z;

	m_top = UTIL_WaterLevel( GetLocalOrigin(), GetLocalOrigin().z, GetLocalOrigin().z + 400 ) - 1;

#if DEBUG_BEAMS
	NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin() + Vector( 0, 0, m_bottom ), 0, 255, 0, false, 0.1f );
	NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin() + Vector( 0, 0, m_top ), 0, 255, 255, false, 0.1f );
#endif

	// Chop off 20% of the outside range
	float newBottom = m_bottom * 0.8 + m_top * 0.2;
	m_top = m_bottom * 0.2 + m_top * 0.8;
	m_bottom = newBottom;
	m_height = random->RandomFloat( m_bottom, m_top );
	m_waterTime = gpGlobals->curtime + random->RandomFloat( 5, 7 );
}

void CNPC_Leech::SwimThink( void )
{
	trace_t			tr;
	float			flLeftSide;
	float			flRightSide;
	float			targetSpeed;
	float			targetYaw = 0;
	CBaseEntity		*pTarget;

	/*if ( !UTIL_FindClientInPVS( edict() ) )
	{
		m_flNextThink = gpGlobals->curtime + random->RandomFloat( 1.0f, 1.5f );
		SetAbsVelocity( vec3_origin );
		return;
	}
	else*/
		SetNextThink( gpGlobals->curtime + 0.1 );

	targetSpeed = LEECH_SWIM_SPEED;

	if ( m_waterTime < gpGlobals->curtime )
		RecalculateWaterlevel();

	if ( m_stateTime < gpGlobals->curtime )
		SwitchLeechState();

	ClearCondition( COND_CAN_MELEE_ATTACK1 );

	switch( m_NPCState )
	{
	case NPC_STATE_COMBAT:
		pTarget = GetEnemy();
		if ( !pTarget )
			SwitchLeechState();
		else
		{
			// Chase the enemy's eyes
			m_height = pTarget->GetLocalOrigin().z + pTarget->GetViewOffset().z - 5;
			// Clip to viable water area
			if ( m_height < m_bottom )
				m_height = m_bottom;
			else if ( m_height > m_top )
				m_height = m_top;
			Vector location = pTarget->GetLocalOrigin() - GetLocalOrigin();
			location.z += (pTarget->GetViewOffset().z);
			if ( location.Length() < 40 )
				SetCondition( COND_CAN_MELEE_ATTACK1 );
			// Turn towards target ent
			targetYaw = UTIL_VecToYaw( location );

			QAngle vTestAngle = GetAbsAngles();
			
			targetYaw = UTIL_AngleDiff( targetYaw, UTIL_AngleMod( GetAbsAngles().y ) );

			if ( targetYaw < (-LEECH_TURN_RATE*0.75) )
				targetYaw = (-LEECH_TURN_RATE*0.75);
			else if ( targetYaw > (LEECH_TURN_RATE*0.75) )
				targetYaw = (LEECH_TURN_RATE*0.75);
			else
				targetSpeed *= 2;
		}

		break;

	default:
		if ( m_zTime < gpGlobals->curtime )
		{
			float newHeight = random->RandomFloat( m_bottom, m_top );
			m_height = 0.5 * m_height + 0.5 * newHeight;
			m_zTime = gpGlobals->curtime + random->RandomFloat( 1, 4 );
		}
		if ( random->RandomInt( 0, 100 ) < 10 )
			targetYaw = random->RandomInt( -30, 30 );
		pTarget = NULL;
		// oldorigin test
		if ( ( GetLocalOrigin() - m_oldOrigin ).Length() < 1 )
		{
			// If leech didn't move, there must be something blocking it, so try to turn
			m_sideTime = 0;
		}

		break;
	}

	m_obstacle = ObstacleDistance( pTarget );
	m_oldOrigin = GetLocalOrigin();
	if ( m_obstacle < 0.1 )
		m_obstacle = 0.1;

	Vector vForward, vRight;

	AngleVectors( GetAbsAngles(), &vForward, &vRight, NULL );

	// is the way ahead clear?
	if ( m_obstacle == 1.0 )
	{
		// if the leech is turning, stop the trend.
		if ( m_flTurning != 0 )
		{
			m_flTurning = 0;
		}

		m_fPathBlocked = FALSE;
		m_flSpeed = UTIL_Approach( targetSpeed, m_flSpeed, LEECH_SWIM_ACCEL * LEECH_FRAMETIME );
		SetAbsVelocity( vForward * m_flSpeed );

	}
	else
	{
		m_obstacle = 1.0 / m_obstacle;
		// IF we get this far in the function, the leader's path is blocked!
		m_fPathBlocked = TRUE;

		if ( m_flTurning == 0 )// something in the way and leech is not already turning to avoid
		{
			Vector vecTest;
			// measure clearance on left and right to pick the best dir to turn
			vecTest = GetLocalOrigin() + ( vRight * LEECH_SIZEX) + ( vForward * LEECH_CHECK_DIST);
			UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
			flRightSide = tr.fraction;

			vecTest = GetLocalOrigin() + ( vRight * -LEECH_SIZEX) + ( vForward * LEECH_CHECK_DIST);
			UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
			
			flLeftSide = tr.fraction;

			// turn left, right or random depending on clearance ratio
			float delta = (flRightSide - flLeftSide);
			if ( delta > 0.1 || (delta > -0.1 && random->RandomInt( 0,100 ) < 50 ) )
				m_flTurning = -LEECH_TURN_RATE;
			else
				m_flTurning = LEECH_TURN_RATE;
		}

		m_flSpeed = UTIL_Approach( -(LEECH_SWIM_SPEED*0.5), m_flSpeed, LEECH_SWIM_DECEL * LEECH_FRAMETIME * m_obstacle );
		SetAbsVelocity( vForward * m_flSpeed );
	}
	
	GetMotor()->SetIdealYaw( m_flTurning );
	UpdateMotion();
}

//
// ObstacleDistance - returns normalized distance to obstacle
//
float CNPC_Leech::ObstacleDistance( CBaseEntity *pTarget )
{
	trace_t			tr;
	Vector			vecTest;
	Vector			vForward, vRight;

	// use VELOCITY, not angles, not all boids point the direction they are flying
	//Vector vecDir = UTIL_VecToAngles( pev->velocity );
	QAngle tmp = GetAbsAngles();
	tmp.x = -tmp.x;
	AngleVectors ( tmp, &vForward, &vRight, NULL );

	// check for obstacle ahead
	vecTest = GetLocalOrigin() + vForward * LEECH_CHECK_DIST;
	UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);

	if ( tr.startsolid )
	{
		m_flSpeed = -LEECH_SWIM_SPEED * 0.5;
	}

	if ( tr.fraction != 1.0 )
	{
		if ( (pTarget == NULL || tr.m_pEnt != pTarget ) )
		{
			return tr.fraction;
		}
		else
		{
			if ( fabs( m_height - GetLocalOrigin().z ) > 10 )
				return tr.fraction;
		}
	}

	if ( m_sideTime < gpGlobals->curtime )
	{
		// extra wide checks
		vecTest = GetLocalOrigin() + vRight * LEECH_SIZEX * 2 + vForward * LEECH_CHECK_DIST;
		UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);

		if (tr.fraction != 1.0)
			return tr.fraction;

		vecTest = GetLocalOrigin() - vRight * LEECH_SIZEX * 2 + vForward * LEECH_CHECK_DIST;
		UTIL_TraceLine( GetLocalOrigin(), vecTest, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
		if (tr.fraction != 1.0)
			return tr.fraction;

		// Didn't hit either side, so stop testing for another 0.5 - 1 seconds
		m_sideTime = gpGlobals->curtime + random->RandomFloat(0.5,1);
	}

	return 1.0;
}

void CNPC_Leech::UpdateMotion( void )
{
	float flapspeed = ( m_flSpeed - m_flAccelerate) / LEECH_ACCELERATE;
	m_flAccelerate = m_flAccelerate * 0.8 + m_flSpeed * 0.2;

	if (flapspeed < 0) 
		flapspeed = -flapspeed;
	flapspeed += 1.0;
	if (flapspeed < 0.5) 
		flapspeed = 0.5;
	if (flapspeed > 1.9) 
		flapspeed = 1.9;

	m_flPlaybackRate = flapspeed;

	QAngle vAngularVelocity = GetLocalAngularVelocity();
	QAngle vAngles = GetLocalAngles();

	if ( !m_fPathBlocked )
		vAngularVelocity.y = GetMotor()->GetIdealYaw();
	else
		vAngularVelocity.y = GetMotor()->GetIdealYaw() * m_obstacle;

	if ( vAngularVelocity.y > 150 )
		SetIdealActivity( ACT_TURN_LEFT );
	else if ( vAngularVelocity.y < -150 )
		SetIdealActivity( ACT_TURN_RIGHT );
	else
		SetIdealActivity( ACT_SWIM );

	// lean
	float targetPitch, delta;
	delta = m_height - GetLocalOrigin().z;

/*	if ( delta < -10 )
		targetPitch = -30;
	else if ( delta > 10 )
		targetPitch = 30;
	else*/
		targetPitch = 0;

	vAngles.x = UTIL_Approach( targetPitch, vAngles.x, 60 * LEECH_FRAMETIME );

	// bank
	vAngularVelocity.z = - ( vAngles.z + (vAngularVelocity.y * 0.25));

	if ( m_NPCState == NPC_STATE_COMBAT && HasCondition( COND_CAN_MELEE_ATTACK1 ) )
		SetIdealActivity( ACT_MELEE_ATTACK1 );

	// Out of water check
	if ( !GetWaterLevel() )
	{
		SetMoveType( MOVETYPE_FLYGRAVITY );
		SetIdealActivity( ACT_HOP );
		SetAbsVelocity( vec3_origin );

		// Animation will intersect the floor if either of these is non-zero
		vAngles.z = 0;
		vAngles.x = 0;

		if ( m_flPlaybackRate < 1.0 )
			 m_flPlaybackRate = 1.0;
	}
	else if ( GetMoveType() == MOVETYPE_FLYGRAVITY )
	{
		SetMoveType( MOVETYPE_FLY );
		RemoveFlag( FL_ONGROUND );

	//  TODO
		RecalculateWaterlevel();
		m_waterTime = gpGlobals->curtime + 2;	// Recalc again soon, water may be rising
	}

	if ( GetActivity() != GetIdealActivity() )
	{
		SetActivity ( GetIdealActivity() );
	}
	StudioFrameAdvance();
	
	DispatchAnimEvents ( this );

	SetLocalAngles( vAngles );
	SetLocalAngularVelocity( vAngularVelocity );

	Vector vForward, vRight;

	AngleVectors( vAngles, &vForward, &vRight, NULL );

#if DEBUG_BEAMS
	if ( m_fPathBlocked )
	{
		float color = m_obstacle * 30;
		if ( m_obstacle == 1.0 )
			color = 0;
		if ( color > 255 )
			color = 255;
		 NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin() + vForward * LEECH_CHECK_DIST, 255, color, color, false, 0.1f );
	}
	else
		 NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin() + vForward * LEECH_CHECK_DIST, 255, 255, 0, false, 0.1f );
		 
	NDebugOverlay::Line( GetLocalOrigin(), GetLocalOrigin() + vRight * (vAngularVelocity.y*0.25), 0, 0, 255, false, 0.1f );
#endif

}

void CNPC_Leech::Event_Killed( const CTakeDamageInfo &info )
{
	Vector			vecSplatDir;
	trace_t			tr;

	//ALERT(at_aiconsole, "Leech: killed\n");
	// tell owner ( if any ) that we're dead.This is mostly for MonsterMaker functionality.
	CBaseEntity *pOwner = GetOwnerEntity();
	if (pOwner)
		pOwner->DeathNotice( this );

	// When we hit the ground, play the "death_end" activity
	if ( GetWaterLevel() )
	{
		QAngle qAngles = GetAbsAngles();
		QAngle qAngularVel = GetLocalAngularVelocity();
		Vector  vOrigin = GetLocalOrigin();

		qAngles.z = 0;
		qAngles.x = 0;

		vOrigin.z += 1;

		SetAbsVelocity( vec3_origin );

		if ( random->RandomInt( 0, 99 ) < 70 )
			 qAngularVel.y = random->RandomInt( -720, 720 );

		SetAbsAngles( qAngles );
		SetLocalAngularVelocity( qAngularVel );
		SetAbsOrigin( vOrigin );

		
		SetGravity ( 0.02 );
		RemoveFlag( FL_ONGROUND );
		SetActivity( ACT_DIESIMPLE );
	}
	else
		SetActivity( ACT_DIEFORWARD );
	
	SetMoveType( MOVETYPE_FLYGRAVITY );
	m_takedamage = DAMAGE_NO;
	
	SetThink( &CNPC_Leech::DeadThink );
}