//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#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_memory.h"
#include	"ai_route.h"
#include	"ai_motor.h"
#include	"soundent.h"
#include	"game.h"
#include	"npcevent.h"
#include	"entitylist.h"
#include	"activitylist.h"
#include	"hl1_basegrenade.h"
#include	"animation.h"
#include	"IEffects.h"
#include	"vstdlib/random.h"
#include	"engine/IEngineSound.h"
#include	"ammodef.h"
#include	"soundenvelope.h"
#include	"hl1_CBaseHelicopter.h"
#include	"ndebugoverlay.h"
#include	"smoke_trail.h"
#include	"beam_shared.h"
#include	"grenade_homer.h"

#define	 HOMER_TRAIL0_LIFE		0.1
#define	 HOMER_TRAIL1_LIFE		0.2
#define	 HOMER_TRAIL2_LIFE		3.0//	1.0

#define  SF_NOTRANSITION 128

extern short g_sModelIndexFireball;

class CNPC_Apache : public CBaseHelicopter
{
	DECLARE_CLASS( CNPC_Apache, CBaseHelicopter );
public:
	DECLARE_DATADESC();

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

	int  BloodColor( void ) { return DONT_BLEED; }
	Class_T  Classify( void ) { return CLASS_HUMAN_MILITARY; };
	void InitializeRotorSound( void );
	void LaunchRocket( Vector &viewDir, int damage, int radius, Vector vecLaunchPoint );

	void Flight( void );

	bool FireGun( void );
	void AimRocketGun( void );
	void FireRocket( void );
	void DyingThink( void );

	int  ObjectCaps( void );
	
	void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );

/*	bool OnInternalDrawModel( ClientModelRenderInfo_t *pInfo )
	{
		BaseClass::OnInteralDrawModel( pInfo );
		Vector origin = GetAbsOrigin();
		origin.z += 32;
		SetAbsOrigin( origin );
	}*/

/*(	void SetAbsOrigin( const Vector& absOrigin )
	{
		((Vector&)absOrigin).z += 32;
		BaseClass::SetAbsOrigin( absOrigin );
	}*/

	

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

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

	
	void Killed( entvars_t *pevAttacker, int iGib );
	void GibMonster( void );

	void EXPORT HuntThink( void );
	void EXPORT FlyTouch( CBaseEntity *pOther );
	void EXPORT CrashTouch( CBaseEntity *pOther );
	void EXPORT DyingThink( void );
	void EXPORT StartupUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
	void EXPORT NullThink( void );

	void ShowDamage( void );
	void Flight( void );
	void FireRocket( void );
	BOOL FireGun( void );
	
	int  TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
	void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);*/

	int m_iRockets;
	float m_flForce;
	float m_flNextRocket;

	int m_iAmmoType;

	Vector m_vecTarget;
	Vector m_posTarget;

	Vector m_vecDesired;
	Vector m_posDesired;

	Vector m_vecGoal;

	QAngle m_angGun;
	
	int m_iSoundState; // don't save this

	int m_iExplode;
	int m_iBodyGibs;
	int	m_nDebrisModel;

	float m_flGoalSpeed;

	CHandle<SmokeTrail>	m_hSmoke;
	CBeam *m_pBeam;
};

BEGIN_DATADESC( CNPC_Apache )
	DEFINE_FIELD( m_iRockets, FIELD_INTEGER ),
	DEFINE_FIELD( m_flForce, FIELD_FLOAT ),
	DEFINE_FIELD( m_flNextRocket, FIELD_TIME ),
	DEFINE_FIELD( m_vecTarget, FIELD_VECTOR ),
	DEFINE_FIELD( m_posTarget, FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_vecDesired, FIELD_VECTOR ),
	DEFINE_FIELD( m_posDesired, FIELD_POSITION_VECTOR ),
	DEFINE_FIELD( m_vecGoal, FIELD_VECTOR ),
	DEFINE_FIELD( m_angGun, FIELD_VECTOR ),
	DEFINE_FIELD( m_flLastSeen, FIELD_TIME ),
	DEFINE_FIELD( m_flPrevSeen, FIELD_TIME ),
//	DEFINE_FIELD( m_iSoundState, FIELD_INTEGER ),
//	DEFINE_FIELD( m_iSpriteTexture, FIELD_INTEGER ),
//	DEFINE_FIELD( m_iExplode, FIELD_INTEGER ),
//	DEFINE_FIELD( m_iBodyGibs, FIELD_INTEGER ),
	DEFINE_FIELD( m_pBeam, FIELD_CLASSPTR ),
	DEFINE_FIELD( m_flGoalSpeed, FIELD_FLOAT ),
	DEFINE_FIELD( m_hSmoke, FIELD_EHANDLE ),
END_DATADESC()

ConVar	sk_apache_health( "sk_apache_health","100");

static Vector s_vecSurroundingMins( -300, -300, -172);
static Vector s_vecSurroundingMaxs(300, 300, 8);


void CNPC_Apache::Spawn( void )
{
	Precache( );
	SetModel( "models/apache.mdl" );

	BaseClass::Spawn();

	AddFlag( FL_NPC );
	SetSolid( SOLID_BBOX );
	SetMoveType( MOVETYPE_STEP );
	AddFlag( FL_FLY );


	m_iHealth			=  sk_apache_health.GetFloat();

	m_flFieldOfView = -0.707; // 270 degrees

	m_fHelicopterFlags	= BITS_HELICOPTER_MISSILE_ON | BITS_HELICOPTER_GUN_ON;

	InitBoneControllers();

	SetRenderColor( 255, 255, 255, 255 );

	m_iRockets = 10;

	UTIL_SetSize( this, Vector( -32, -32, -32 ), Vector( 32, 32, 32 ) );

	//CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &s_vecSurroundingMins, &s_vecSurroundingMaxs );
	//AddSolidFlags( FSOLID_CUSTOMRAYTEST | FSOLID_CUSTOMBOXTEST );

	m_hSmoke = NULL;
}

LINK_ENTITY_TO_CLASS ( monster_apache, CNPC_Apache );

int CNPC_Apache::ObjectCaps( void ) 
{ 
	if ( GetSpawnFlags() & SF_NOTRANSITION )
	     return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; 
	else 
		 return BaseClass::ObjectCaps();
}

void CNPC_Apache::Precache( void )
{
	// Get to tha chopper!
	PrecacheModel( "models/apache.mdl" );
	PrecacheScriptSound( "Apache.Rotor" );
	m_nDebrisModel = PrecacheModel(   "models/metalplategibs_green.mdl" );

	// Gun
	PrecacheScriptSound( "Apache.FireGun" );
	m_iAmmoType = GetAmmoDef()->Index("9mmRound"); 

	// Rockets
	UTIL_PrecacheOther( "grenade_homer" );
	PrecacheScriptSound( "Apache.RPG" );
	PrecacheModel( "models/weapons/w_missile.mdl" );

	BaseClass::Precache();
}

void CNPC_Apache::InitializeRotorSound( void )
{
	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

	CPASAttenuationFilter filter( this );
	m_pRotorSound	= controller.SoundCreate( filter, entindex(), "Apache.Rotor" );

	BaseClass::InitializeRotorSound();
}

void CNPC_Apache::Flight( void )
{
	StudioFrameAdvance( );

	float flDistToDesiredPosition = (GetAbsOrigin() - m_vecDesiredPosition).Length();
	// NDebugOverlay::Line(GetAbsOrigin(), m_vecDesiredPosition, 0,0,255, true, 0.1);

	if (m_flGoalSpeed < 800 )
		m_flGoalSpeed += GetAcceleration();


//	Vector vecGoalOrientation;
	if (flDistToDesiredPosition > 250) // 500
	{
		Vector v1 = (m_vecTargetPosition - GetAbsOrigin());
		Vector v2 = (m_vecDesiredPosition - GetAbsOrigin());

		VectorNormalize( v1 );
		VectorNormalize( v2 );

		if (m_flLastSeen + 90 > gpGlobals->curtime && DotProduct( v1, v2 ) > 0.25)
		{
			m_vecGoalOrientation = ( m_vecTargetPosition - GetAbsOrigin());
		}
		else
		{
			m_vecGoalOrientation = (m_vecDesiredPosition - GetAbsOrigin());
		}
		VectorNormalize( m_vecGoalOrientation );
	}
	else
	{
		AngleVectors( GetGoalEnt()->GetAbsAngles(), &m_vecGoalOrientation );
	}
//	SetGoalOrientation( vecGoalOrientation );
	

	if (GetGoalEnt())
	{
		// ALERT( at_console, "%.0f\n", flLength );
		if ( HasReachedTarget() )
		{
			// If we get this close to the desired position, it's assumed that we've reached
			// the desired position, so move on.

			// Fire target that I've reached my goal
			m_AtTarget.FireOutput( GetGoalEnt(), this );

			OnReachedTarget( GetGoalEnt() );

			SetGoalEnt( gEntList.FindEntityByName( NULL, GetGoalEnt()->m_target ) );

			if (GetGoalEnt())
			{
				m_vecDesiredPosition = GetGoalEnt()->GetAbsOrigin();
				
//				Vector vecGoalOrientation;
				AngleVectors( GetGoalEnt()->GetAbsAngles(), &m_vecGoalOrientation );

//				SetGoalOrientation( vecGoalOrientation );

				flDistToDesiredPosition = (GetAbsOrigin() - m_vecDesiredPosition).Length();
			}
		}
	}
	else
	{
		// If we can't find a new target, just stay where we are.
		m_vecDesiredPosition = GetAbsOrigin();
	}

	// tilt model 5 degrees
	QAngle angAdj = QAngle( 5.0, 0, 0 );

	// estimate where I'll be facing in one seconds
	Vector forward, right, up;
	AngleVectors( GetAbsAngles() + GetLocalAngularVelocity() * 2 + angAdj, &forward, &right, &up );
	// Vector vecEst1 = GetAbsOrigin() + pev->velocity + gpGlobals->v_up * m_flForce - Vector( 0, 0, 384 );
	// float flSide = DotProduct( m_posDesired - vecEst1, gpGlobals->v_right );
	

	QAngle angVel = GetLocalAngularVelocity();
	float flSide = DotProduct( m_vecGoalOrientation, right );

	if (flSide < 0)
	{
		if ( angVel.y < 60)
		{
			 angVel.y += 8; // 9 * (3.0/2.0);
		}
	}
	else
	{
		if ( angVel.y > -60)
		{
			 angVel.y -= 8; // 9 * (3.0/2.0);
		}
	}
	angVel.y *= 0.98;
	SetLocalAngularVelocity( angVel );

	Vector vecVel = GetAbsVelocity();

	// estimate where I'll be in two seconds
	AngleVectors( GetAbsAngles() + GetLocalAngularVelocity() * 1 + angAdj, &forward, &right, &up );
	Vector vecEst = GetAbsOrigin() + vecVel * 2.0 + up * m_flForce * 20 - Vector( 0, 0, 384 * 2 );

	// add immediate force
	AngleVectors( GetAbsAngles() + angAdj, &forward, &right, &up );

	vecVel.x += up.x * m_flForce;
	vecVel.y += up.y * m_flForce;
	vecVel.z += up.z * m_flForce;
	// add gravity
	vecVel.z -= 38.4; // 32ft/sec

	float flSpeed = vecVel.Length();
	float flDir = DotProduct( Vector( forward.x, forward.y, 0 ), Vector( vecVel.x, vecVel.y, 0 ) );
	if (flDir < 0)
		flSpeed = -flSpeed;

	float flDist = DotProduct( m_vecDesiredPosition - vecEst, forward );

	// float flSlip = DotProduct( pev->velocity, gpGlobals->v_right );
	float flSlip = -DotProduct( m_vecDesiredPosition - vecEst, right );

	angVel = GetLocalAngularVelocity();
	// fly sideways
	if (flSlip > 0)
	{
		if (GetAbsAngles().z > -30 && angVel.z > -15)
			angVel.z -= 4;
		else
			angVel.z += 2;
	}
	else
	{

		if (GetAbsAngles().z < 30 && angVel.z < 15)
			angVel.z += 4;
		else
			angVel.z -= 2;
	}
	SetLocalAngularVelocity( angVel );

	// sideways drag
	vecVel.x = vecVel.x * (1.0 - fabs( right.x ) * 0.05);
    vecVel.y = vecVel.y * (1.0 - fabs( right.y ) * 0.05);
	vecVel.z = vecVel.z * (1.0 - fabs( right.z ) * 0.05);

	// general drag
	vecVel = vecVel * 0.995;

	// Set final computed velocity
	SetAbsVelocity( vecVel );
	
	// apply power to stay correct height
	if (m_flForce < 80 && vecEst.z < m_vecDesiredPosition.z) 
	{
		m_flForce += 12;
	}
	else if (m_flForce > 30)
	{
		if (vecEst.z > m_vecDesiredPosition.z) 
			m_flForce -= 8;
	}


	angVel = GetLocalAngularVelocity();
	// pitch forward or back to get to target
	if (flDist > 0 && flSpeed < m_flGoalSpeed && GetAbsAngles().x + angVel.x < 40)
	{
		// ALERT( at_console, "F " );
		// lean forward
		angVel.x += 12.0;
	}
	else if (flDist < 0 && flSpeed > -50 && GetAbsAngles().x + angVel.x  > -20)
	{
		// ALERT( at_console, "B " );
		// lean backward
		angVel.x -= 12.0;
	}
	else if (GetAbsAngles().x + angVel.x < 0)
	{
		// ALERT( at_console, "f " );
		angVel.x += 4.0;
	}
	else if (GetAbsAngles().x + angVel.x > 0)
	{
		// ALERT( at_console, "b " );
		angVel.x -= 4.0;
	}

	// Set final computed angular velocity
	SetLocalAngularVelocity( angVel );

	// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", GetAbsOrigin().x, pev->velocity.x, flDist, flSpeed, GetAbsAngles().x, pev->avelocity.x, m_flForce ); 
	// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", GetAbsOrigin().z, pev->velocity.z, vecEst.z, m_posDesired.z, m_flForce ); 
}

//------------------------------------------------------------------------------
// Purpose :
// Input   :
// Output  :
//------------------------------------------------------------------------------

#define CHOPPER_AP_GUN_TIP			0
#define CHOPPER_AP_GUN_BASE			1

#define CHOPPER_BC_GUN_YAW			0
#define CHOPPER_BC_GUN_PITCH		1
#define CHOPPER_BC_POD_PITCH		2

bool CNPC_Apache::FireGun( )
{
	if ( !GetEnemy() )
		return false;

	Vector vForward, vRight, vUp;

	AngleVectors( GetAbsAngles(), &vForward, &vUp, &vRight );
		
	Vector posGun;
	QAngle angGun;
	GetAttachment( 1, posGun, angGun );

	Vector vecTarget = (m_vecTargetPosition - posGun);

	VectorNormalize( vecTarget );

	Vector vecOut;

	vecOut.x = DotProduct( vForward, vecTarget );
	vecOut.y = -DotProduct( vUp, vecTarget );
	vecOut.z = DotProduct( vRight, vecTarget );

	QAngle angles;

	VectorAngles( vecOut, angles );
	
	angles.y = AngleNormalize(angles.y);
	angles.x = AngleNormalize(angles.x);	

	if (angles.x > m_angGun.x)
		m_angGun.x = MIN( angles.x, m_angGun.x + 12 );
	if (angles.x < m_angGun.x)
		m_angGun.x = MAX( angles.x, m_angGun.x - 12 );
	if (angles.y > m_angGun.y)
		m_angGun.y = MIN( angles.y, m_angGun.y + 12 );
	if (angles.y < m_angGun.y)
		m_angGun.y = MAX( angles.y, m_angGun.y - 12 );

	// hacks - shouldn't be hardcoded, oh well.
	// limit it so it doesn't pop if you try to set it to the max value
	m_angGun.y = clamp( m_angGun.y, -89.9, 89.9 );
	m_angGun.x = clamp( m_angGun.x, -9.9, 44.9 );

	m_angGun.y = SetBoneController( 0, m_angGun.y );
	m_angGun.x = SetBoneController( 1, m_angGun.x );

	Vector posBarrel;
	QAngle angBarrel;
	GetAttachment( 0, posBarrel, angBarrel );

	Vector forward;
	AngleVectors( angBarrel + m_angGun, &forward );

	Vector2D vec2LOS = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() ).AsVector2D();
	vec2LOS.NormalizeInPlace();

	float flDot = vec2LOS.Dot( forward.AsVector2D() );

	//forward
//	NDebugOverlay::Line(  GetAbsOrigin(), GetAbsOrigin() + ( forward * 200 ), 255,0,0, false, 0.1);
	//LOS
//	NDebugOverlay::Line( posGun, m_vecTargetPosition , 0,0,255, false, 0.1);
//	NDebugOverlay::Box( GetAbsOrigin(), s_vecSurroundingMins, s_vecSurroundingMaxs, 0, 255,0, false, 0.1);

	if ( flDot > 0.98 )
	{
		CPASAttenuationFilter filter( this, 0.2f );

		EmitSound( filter, entindex(), "Apache.FireGun" );//<<TEMP>>temp sound

		// gun is a bit dodgy, just fire at the target if we are close
		FireBullets( 1, posGun, vecTarget, VECTOR_CONE_4DEGREES, 8192, m_iAmmoType, 2 );

		return true;
	}

	return false;
}

void CNPC_Apache::FireRocket( void )
{
	static float side = 1.0;
	static int count;
	Vector vForward, vRight, vUp;


	AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
	Vector vecSrc = GetAbsOrigin() + 1.5 * ( vForward * 21 + vRight * 70 * side + vUp * -79 );

	// pick firing pod to launch from
	switch( m_iRockets % 5)
	{
	case 0:	vecSrc = vecSrc + vRight * 10; break;
	case 1: vecSrc = vecSrc - vRight * 10; break;
	case 2: vecSrc = vecSrc + vUp * 10; break;
	case 3: vecSrc = vecSrc - vUp * 10; break;
	case 4: break;
	}

	Vector vTargetDir = m_vecTargetPosition - GetAbsOrigin();
	VectorNormalize ( vTargetDir );
	LaunchRocket( vTargetDir, 100, 150, vecSrc);

	m_iRockets--;

	side = - side;
}
void CNPC_Apache::AimRocketGun( void )
{
	Vector vForward, vRight, vUp;
	
	if (m_iRockets <= 0)
		return;
	
	Vector vTargetDir = m_vecTargetPosition - GetAbsOrigin();
	VectorNormalize ( vTargetDir );

	AngleVectors( GetAbsAngles(), &vForward, &vRight, &vUp );
	Vector vecEst = ( vForward * 800 + GetAbsVelocity());
	VectorNormalize ( vecEst );

	trace_t tr1;
	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vecEst * 4096, MASK_ALL, this, COLLISION_GROUP_NONE, &tr1);

//	NDebugOverlay::Line(GetAbsOrigin(), tr1.endpos, 255,255,0, false, 0.1);

	UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vTargetDir * 4096, MASK_ALL, this, COLLISION_GROUP_NONE, &tr1);

//	NDebugOverlay::Line(GetAbsOrigin(), tr1.endpos, 0,255,0, false, 0.1);

	// ALERT( at_console, "%d %d %d %4.2f\n", GetAbsAngles().x < 0, DotProduct( pev->velocity, gpGlobals->v_forward ) > -100, m_flNextRocket < gpGlobals->curtime, DotProduct( m_vecTarget, vecEst ) );

	if ((m_iRockets % 2) == 1)
	{
		FireRocket( );
		m_flNextRocket = gpGlobals->curtime + 0.5;
		if (m_iRockets <= 0)
		{
			m_flNextRocket = gpGlobals->curtime + 10;
			m_iRockets = 10;
		}
	}
	else if (DotProduct( GetAbsVelocity(), vForward ) > -100 && m_flNextRocket < gpGlobals->curtime)
	{
		if (m_flLastSeen + 60 > gpGlobals->curtime)
		{
			if (GetEnemy() != NULL)
			{
				// make sure it's a good shot
				//if (DotProduct( vTargetDir, vecEst) > 0.5)
				{
					trace_t tr;
					
					UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vecEst * 4096, MASK_ALL, this, COLLISION_GROUP_NONE, &tr);

			//		NDebugOverlay::Line(GetAbsOrigin(), tr.endpos, 255,0,255, false, 5);

//					if ((tr.endpos - m_vecTargetPosition).Length() < 512)
					if ((tr.endpos - m_vecTargetPosition).Length() < 1024)
						FireRocket( );
				}
			}
			else
			{
				trace_t tr;
				
				UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + vecEst * 4096, MASK_ALL, this, COLLISION_GROUP_NONE, &tr);
				// just fire when close
				if ((tr.endpos - m_vecTargetPosition).Length() < 512)
					FireRocket( );
			}
		}
	}
}

#define MISSILE_HOMING_STRENGTH		0.3
#define MISSILE_HOMING_DELAY		5.0
#define MISSILE_HOMING_RAMP_UP		0.5
#define MISSILE_HOMING_DURATION		1.0
#define MISSILE_HOMING_RAMP_DOWN	0.5

void CNPC_Apache::LaunchRocket( Vector &viewDir, int damage, int radius, Vector vecLaunchPoint )
{

	CGrenadeHomer *pGrenade = CGrenadeHomer::CreateGrenadeHomer( 
		MAKE_STRING("models/weapons/w_missile.mdl"), 
		MAKE_STRING( "Apache.RPG" ), 
		vecLaunchPoint, vec3_angle, edict() );
	pGrenade->Spawn( );
	pGrenade->SetHoming(MISSILE_HOMING_STRENGTH, MISSILE_HOMING_DELAY,
						MISSILE_HOMING_RAMP_UP,	MISSILE_HOMING_DURATION,
						MISSILE_HOMING_RAMP_DOWN);
	pGrenade->SetDamage( damage );
	pGrenade->m_DmgRadius = radius;

	pGrenade->Launch( this, GetEnemy(), viewDir * 1500, 500, 0, HOMER_SMOKE_TRAIL_ON );

}


//-----------------------------------------------------------------------------
// Purpose:	Lame, temporary death
//-----------------------------------------------------------------------------
void CNPC_Apache::DyingThink( void )
{
	StudioFrameAdvance( );
	SetNextThink( gpGlobals->curtime + 0.1f );

	if( gpGlobals->curtime > m_flNextCrashExplosion )
	{
		CPASFilter pasFilter( GetAbsOrigin() );
		Vector pos;

		pos = GetAbsOrigin();
		pos.x += random->RandomFloat( -150, 150 );
		pos.y += random->RandomFloat( -150, 150 );
		pos.z += random->RandomFloat( -150, -50 );

		te->Explosion( pasFilter, 0.0,	&pos, g_sModelIndexFireball, 10, 15, TE_EXPLFLAG_NONE, 100, 0 );
		
		Vector vecSize = Vector( 500, 500, 60 );
		CPVSFilter pvsFilter( GetAbsOrigin() );

		te->BreakModel( pvsFilter, 0.0, GetAbsOrigin(), vec3_angle, vecSize, vec3_origin, 
			m_nDebrisModel, 100, 0, 2.5, BREAK_METAL );

		m_flNextCrashExplosion = gpGlobals->curtime + random->RandomFloat( 0.3, 0.5 );
	}

	QAngle angVel = GetLocalAngularVelocity();
	if( angVel.y < 400 )
	{
		angVel.y *= 1.1;
		SetLocalAngularVelocity( angVel );
	}

	Vector vecImpulse( 0, 0, -38.4 );	// gravity - 32ft/sec
	ApplyAbsVelocityImpulse( vecImpulse );

	if( m_hSmoke )
	{
		m_hSmoke->SetLifetime(0.1f);
		m_hSmoke = NULL;
	}

}



void CNPC_Apache::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{

	CTakeDamageInfo dmgInfo = info;

	// HITGROUPS don't work currently.
	// ignore blades
	//if (ptr->hitgroup == 6 && (info.GetDamageType() & (DMG_ENERGYBEAM|DMG_BULLET|DMG_CLUB)))
	//		return;

	// hit hard, hits cockpit
	if (info.GetDamage() > 50 || ptr->hitgroup == 1 || ptr->hitgroup == 2 || ptr->hitgroup == 3 )
	{
		// ALERT( at_console, "%map .0f\n", flDamage );
		AddMultiDamage( dmgInfo, this );

		if ( info.GetDamage() > 50 )
		{
			if ( m_hSmoke == NULL && (m_hSmoke = SmokeTrail::CreateSmokeTrail()) != NULL )
			{
				m_hSmoke->m_Opacity = 1.0f;
				m_hSmoke->m_SpawnRate = 60;
				m_hSmoke->m_ParticleLifetime = 1.3f;
				m_hSmoke->m_StartColor.Init( 0.65f, 0.65f , 0.65f );
				m_hSmoke->m_EndColor.Init( 0.65f, 0.65f, 0.65f );
				m_hSmoke->m_StartSize = 12;
				m_hSmoke->m_EndSize = 64;
				m_hSmoke->m_SpawnRadius = 8;
				m_hSmoke->m_MinSpeed = 2;
				m_hSmoke->m_MaxSpeed = 24;				

				m_hSmoke->SetLifetime( 1e6 );
				m_hSmoke->FollowEntity( this );

			}
		}
	}
	else
	{
		// do half damage in the body
		dmgInfo.ScaleDamage(0.5);
		AddMultiDamage( dmgInfo, this );
		g_pEffects->Ricochet( ptr->endpos, ptr->plane.normal );
	}

	if ( m_iHealth < 10 )
	{
		if ( m_hSmoke == NULL && (m_hSmoke = SmokeTrail::CreateSmokeTrail()) != NULL )
		{
			m_hSmoke->m_Opacity = 1.0f;
			m_hSmoke->m_SpawnRate = 60;
			m_hSmoke->m_ParticleLifetime = 1.3f;
			m_hSmoke->m_StartColor.Init( 0.65f, 0.65f , 0.65f );
			m_hSmoke->m_EndColor.Init( 0.65f, 0.65f, 0.65f );
			m_hSmoke->m_StartSize = 12;
			m_hSmoke->m_EndSize = 64;
			m_hSmoke->m_SpawnRadius = 8;
			m_hSmoke->m_MinSpeed = 2;
			m_hSmoke->m_MaxSpeed = 24;				

			m_hSmoke->SetLifetime( 1e6 );
			m_hSmoke->FollowEntity( this );

		}
	}
}