Fix line endings. WHAMMY.

1 files changed, 3428 insertions, 3428 deletions

diff --git a/mp/src/game/server/hl2/npc_manhack.cpp b/mp/src/game/server/hl2/npc_manhack.cpp
index 5dc22f8f..feef84f8 100644
--- a/mp/src/game/server/hl2/npc_manhack.cpp
+++ b/mp/src/game/server/hl2/npc_manhack.cpp
@@ -1,3428 +1,3428 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-//=============================================================================//

-

-#include "cbase.h"

-#include "soundenvelope.h"

-#include "npc_manhack.h"

-#include "ai_default.h"

-#include "ai_node.h"

-#include "ai_navigator.h"

-#include "ai_pathfinder.h"

-#include "ai_moveprobe.h"

-#include "ai_memory.h"

-#include "ai_squad.h"

-#include "ai_route.h"

-#include "explode.h"

-#include "basegrenade_shared.h"

-#include "ndebugoverlay.h"

-#include "decals.h"

-#include "gib.h"

-#include "game.h"			

-#include "ai_interactions.h"

-#include "IEffects.h"

-#include "vstdlib/random.h"

-#include "engine/IEngineSound.h"

-#include "movevars_shared.h"

-#include "npcevent.h"

-#include "props.h"

-#include "te_effect_dispatch.h"

-#include "ai_squadslot.h"

-#include "world.h"

-#include "smoke_trail.h"

-#include "func_break.h"

-#include "physics_impact_damage.h"

-#include "weapon_physcannon.h"

-#include "physics_prop_ragdoll.h"

-#include "soundent.h"

-#include "ammodef.h"

-

-// memdbgon must be the last include file in a .cpp file!!!

-#include "tier0/memdbgon.h"

-

-// When the engine is running and the manhack is operating under power

-// we don't let gravity affect him.

-#define MANHACK_GRAVITY 0.000

-

-#define MANHACK_GIB_COUNT			5 

-#define MANHACK_INGORE_WATER_DIST	384

-

-// Sound stuff

-#define MANHACK_PITCH_DIST1		512

-#define MANHACK_MIN_PITCH1		(100)

-#define MANHACK_MAX_PITCH1		(160)

-#define MANHACK_WATER_PITCH1	(85)

-#define MANHACK_VOLUME1			0.55

-

-#define MANHACK_PITCH_DIST2		400

-#define MANHACK_MIN_PITCH2		(85)

-#define MANHACK_MAX_PITCH2		(190)

-#define MANHACK_WATER_PITCH2	(90)

-

-#define MANHACK_NOISEMOD_HIDE 5000

-

-#define MANHACK_BODYGROUP_BLADE	1

-#define MANHACK_BODYGROUP_BLUR	2

-#define MANHACK_BODYGROUP_OFF	0

-#define MANHACK_BODYGROUP_ON	1

-

-// ANIMATION EVENTS

-#define MANHACK_AE_START_ENGINE			50

-#define MANHACK_AE_DONE_UNPACKING		51

-#define MANHACK_AE_OPEN_BLADE			52

-

-//#define MANHACK_GLOW_SPRITE	"sprites/laserdot.vmt"

-#define MANHACK_GLOW_SPRITE	"sprites/glow1.vmt"

-

-#define	MANHACK_CHARGE_MIN_DIST	200

-

-ConVar	sk_manhack_health( "sk_manhack_health","0");

-ConVar	sk_manhack_melee_dmg( "sk_manhack_melee_dmg","0");

-ConVar	sk_manhack_v2( "sk_manhack_v2","1");

-

-extern void		SpawnBlood(Vector vecSpot, const Vector &vAttackDir, int bloodColor, float flDamage);

-extern float	GetFloorZ(const Vector &origin);

-

-//-----------------------------------------------------------------------------

-// Private activities.

-//-----------------------------------------------------------------------------

-Activity ACT_MANHACK_UNPACK;

-

-//-----------------------------------------------------------------------------

-// Manhack Conditions

-//-----------------------------------------------------------------------------

-enum ManhackConditions

-{

-	COND_MANHACK_START_ATTACK = LAST_SHARED_CONDITION,	// We are able to do a bombing run on the current enemy.

-};

-

-//-----------------------------------------------------------------------------

-// Manhack schedules.

-//-----------------------------------------------------------------------------

-enum ManhackSchedules

-{

-	SCHED_MANHACK_ATTACK_HOVER = LAST_SHARED_SCHEDULE,

-	SCHED_MANHACK_DEPLOY,

-	SCHED_MANHACK_REGROUP,

-	SCHED_MANHACK_SWARM_IDLE,

-	SCHED_MANHACK_SWARM,

-	SCHED_MANHACK_SWARM_FAILURE,

-};

-

-

-//-----------------------------------------------------------------------------

-// Manhack tasks.

-//-----------------------------------------------------------------------------

-enum ManhackTasks

-{

-	TASK_MANHACK_HOVER = LAST_SHARED_TASK,

-	TASK_MANHACK_UNPACK,

-	TASK_MANHACK_FIND_SQUAD_CENTER,

-	TASK_MANHACK_FIND_SQUAD_MEMBER,

-	TASK_MANHACK_MOVEAT_SAVEPOSITION,

-};

-

-BEGIN_DATADESC( CNPC_Manhack )

-

-	DEFINE_FIELD( m_vForceVelocity,			FIELD_VECTOR),

-

-	DEFINE_FIELD( m_vTargetBanking,			FIELD_VECTOR),

-	DEFINE_FIELD( m_vForceMoveTarget,			FIELD_POSITION_VECTOR),

-	DEFINE_FIELD( m_fForceMoveTime,			FIELD_TIME),

-	DEFINE_FIELD( m_vSwarmMoveTarget,			FIELD_POSITION_VECTOR),

-	DEFINE_FIELD( m_fSwarmMoveTime,			FIELD_TIME),

-	DEFINE_FIELD( m_fEnginePowerScale,		FIELD_FLOAT),

-

-	DEFINE_FIELD( m_flNextEngineSoundTime,	FIELD_TIME),

-	DEFINE_FIELD( m_flEngineStallTime,		FIELD_TIME),

-	DEFINE_FIELD( m_flNextBurstTime,			FIELD_TIME ),

-	DEFINE_FIELD( m_flWaterSuspendTime,		FIELD_TIME),

-	DEFINE_FIELD( m_nLastSpinSound,			FIELD_INTEGER ),

-

-	// Death

-	DEFINE_FIELD( m_fSparkTime,				FIELD_TIME),

-	DEFINE_FIELD( m_fSmokeTime,				FIELD_TIME),

-

-	DEFINE_FIELD( m_bDirtyPitch,			FIELD_BOOLEAN ),

-	DEFINE_FIELD( m_bGib,					FIELD_BOOLEAN),

-	DEFINE_FIELD( m_bHeld,					FIELD_BOOLEAN),

-	

-	DEFINE_FIELD( m_bHackedByAlyx,			FIELD_BOOLEAN),

-	DEFINE_FIELD( m_vecLoiterPosition,		FIELD_POSITION_VECTOR),

-	DEFINE_FIELD( m_fTimeNextLoiterPulse,	FIELD_TIME),

-

-	DEFINE_FIELD( m_flBumpSuppressTime,		FIELD_TIME ),

-

-	DEFINE_FIELD( m_bBladesActive,			FIELD_BOOLEAN),

-	DEFINE_FIELD( m_flBladeSpeed,				FIELD_FLOAT),

-	DEFINE_KEYFIELD( m_bIgnoreClipbrushes,	FIELD_BOOLEAN, "ignoreclipbrushes" ),

-	DEFINE_FIELD( m_hSmokeTrail,				FIELD_EHANDLE),

-

-	// DEFINE_FIELD( m_pLightGlow,				FIELD_CLASSPTR ),

-	// DEFINE_FIELD( m_pEyeGlow,					FIELD_CLASSPTR ),

-

-	DEFINE_FIELD( m_iPanel1, FIELD_INTEGER ),

-	DEFINE_FIELD( m_iPanel2, FIELD_INTEGER ),

-	DEFINE_FIELD( m_iPanel3, FIELD_INTEGER ),

-	DEFINE_FIELD( m_iPanel4, FIELD_INTEGER ),

-

-	DEFINE_FIELD( m_nLastWaterLevel,			FIELD_INTEGER ),

-	DEFINE_FIELD( m_bDoSwarmBehavior,			FIELD_BOOLEAN ),

-

-	DEFINE_FIELD( m_nEnginePitch1,				FIELD_INTEGER ),

-	DEFINE_FIELD( m_flEnginePitch1Time,			FIELD_TIME ),

-	DEFINE_FIELD( m_nEnginePitch2,				FIELD_INTEGER ),

-	DEFINE_FIELD( m_flEnginePitch2Time,			FIELD_TIME ),

-

-	// Physics Influence

-	DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ),

-	DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ),

-

-	DEFINE_FIELD( m_flBurstDuration,	FIELD_FLOAT ),

-	DEFINE_FIELD( m_vecBurstDirection,	FIELD_VECTOR ),

-	DEFINE_FIELD( m_bShowingHostile,	FIELD_BOOLEAN ),

-

-	// Function Pointers

-	DEFINE_INPUTFUNC( FIELD_VOID,	"DisableSwarm", InputDisableSwarm ),

-	DEFINE_INPUTFUNC( FIELD_VOID,   "Unpack",		InputUnpack ),

-

-	DEFINE_ENTITYFUNC( CrashTouch ),

-

-	DEFINE_BASENPCINTERACTABLE_DATADESC(),

-

-END_DATADESC()

-

-

-LINK_ENTITY_TO_CLASS( npc_manhack, CNPC_Manhack );

-

-IMPLEMENT_SERVERCLASS_ST(CNPC_Manhack, DT_NPC_Manhack)

-	SendPropIntWithMinusOneFlag	(SENDINFO(m_nEnginePitch1), 8 ),

-	SendPropFloat(SENDINFO(m_flEnginePitch1Time), 0, SPROP_NOSCALE),

-	SendPropIntWithMinusOneFlag(SENDINFO(m_nEnginePitch2), 8 )

-END_SEND_TABLE()

-

-

-

-//------------------------------------------------------------------------------

-// Purpose :

-// Input   :

-// Output  :

-//------------------------------------------------------------------------------

-CNPC_Manhack::CNPC_Manhack()

-{

-#ifdef _DEBUG

-	m_vForceMoveTarget.Init();

-	m_vSwarmMoveTarget.Init();

-	m_vTargetBanking.Init();

-	m_vForceVelocity.Init();

-#endif

-	m_bDirtyPitch = true;

-	m_nLastWaterLevel = 0;

-	m_nEnginePitch1 = -1;

-	m_nEnginePitch2 = -1;

-	m_flEnginePitch1Time = 0;

-	m_flEnginePitch1Time = 0;

-	m_bDoSwarmBehavior = true;

-	m_flBumpSuppressTime = 0;

-}

-

-//------------------------------------------------------------------------------

-// Purpose:

-//------------------------------------------------------------------------------

-CNPC_Manhack::~CNPC_Manhack()

-{

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Indicates this NPC's place in the relationship table.

-//-----------------------------------------------------------------------------

-Class_T	CNPC_Manhack::Classify(void)

-{

-	return (m_bHeld||m_bHackedByAlyx) ? CLASS_PLAYER_ALLY : CLASS_MANHACK; 

-}

-

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Turns the manhack into a physics corpse when dying.

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Event_Dying(void)

-{

-	DestroySmokeTrail();

-	SetHullSizeNormal();

-	BaseClass::Event_Dying();

-}

-

-

-//-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::GatherConditions()

-{

-	BaseClass::GatherConditions();

-

-	if( IsLoitering() && GetEnemy() )

-	{

-		StopLoitering();

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::PrescheduleThink( void )

-{

-	BaseClass::PrescheduleThink();

-

-	UpdatePanels();

-

-	if( m_flWaterSuspendTime > gpGlobals->curtime )

-	{

-		// Stuck in water!

-

-		// Reduce engine power so that the manhack lifts out of the water slowly.

-		m_fEnginePowerScale = 0.75;

-	}

-

-	// ----------------------------------------

-	//	Am I in water?

-	// ----------------------------------------

-	if ( GetWaterLevel() > 0 )

-	{

-		if( m_nLastWaterLevel == 0 )

-		{

-			Splash( WorldSpaceCenter() );

-		}

-

-		if( IsAlive() )

-		{

-			// If I've been out of water for 2 seconds or more, I'm eligible to be stuck in water again.

-			if( gpGlobals->curtime - m_flWaterSuspendTime > 2.0 )

-			{

-				m_flWaterSuspendTime = gpGlobals->curtime + 1.0;

-			}

-		}

-	}

-	else

-	{

-		if( m_nLastWaterLevel != 0 )

-		{

-			Splash( WorldSpaceCenter() );

-		}

-	}

-

-	m_nLastWaterLevel = GetWaterLevel();

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

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

-{

-	g_vecAttackDir = vecDir;

-

-	if ( info.GetDamageType() & DMG_BULLET)

-	{

-		g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);

-	}

-

-	if ( info.GetDamageType() & DMG_CLUB )

-	{

-		// Clubbed!

-//		UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10);

-		g_pEffects->Sparks( ptr->endpos, 1, 1, &ptr->plane.normal );

-	}

-

-	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::DeathSound( const CTakeDamageInfo &info )

-{

-	StopSound("NPC_Manhack.Stunned");

-	CPASAttenuationFilter filter2( this, "NPC_Manhack.Die" );

-	EmitSound( filter2, entindex(), "NPC_Manhack.Die" );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Output : Returns true on success, false on failure.

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::ShouldGib( const CTakeDamageInfo &info )

-{

-	return ( m_bGib );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Event_Killed( const CTakeDamageInfo &info )

-{

-	// turn off the blur!

-	SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );

-

-	// Sparks

-	for (int i = 0; i < 3; i++)

-	{

-		Vector sparkPos = GetAbsOrigin();

-		sparkPos.x += random->RandomFloat(-12,12);

-		sparkPos.y += random->RandomFloat(-12,12);

-		sparkPos.z += random->RandomFloat(-12,12);

-		g_pEffects->Sparks( sparkPos, 2 );

-	}

-

-	// Light

-	CBroadcastRecipientFilter filter;

-	te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 100, 0.1, 0 );

-

-	if ( m_nEnginePitch1 < 0 )

-	{

-		// Probably this manhack was killed immediately after spawning. Turn the sound

-		// on right now so that we can pitch it up for the crash!

-		SoundInit();

-	}

-

-	// Always gib when clubbed or blasted or crushed, or just randomly

-	if ( ( info.GetDamageType() & (DMG_CLUB|DMG_CRUSH|DMG_BLAST) ) || ( random->RandomInt( 0, 1 ) ) )

-	{

-		m_bGib = true;

-	}

-	else

-	{

-		m_bGib = false;

-		

-		//FIXME: These don't stay with the ragdolls currently -- jdw

-		// Long fadeout on the sprites!!

-		KillSprites( 0.0f );

-	}

-

-	BaseClass::Event_Killed( info );

-}

-

-void CNPC_Manhack::HitPhysicsObject( CBaseEntity *pOther )

-{

-	IPhysicsObject *pOtherPhysics = pOther->VPhysicsGetObject();

-	Vector pos, posOther;

-	// Put the force on the line between the manhack origin and hit object origin

-	VPhysicsGetObject()->GetPosition( &pos, NULL );

-	pOtherPhysics->GetPosition( &posOther, NULL );

-	Vector dir = posOther - pos;

-	VectorNormalize(dir);

-	// size/2 is approx radius

-	pos += dir * WorldAlignSize().x * 0.5;

-	Vector cross;

-

-	// UNDONE: Use actual manhack up vector so the fake blade is

-	// in the right plane?

-	// Get a vector in the x/y plane in the direction of blade spin (clockwise)

-	CrossProduct( dir, Vector(0,0,1), cross );

-	VectorNormalize( cross );

-	// force is a 30kg object going 100 in/s

-	pOtherPhysics->ApplyForceOffset( cross * 30 * 100, pos );

-}

-

-

-//-----------------------------------------------------------------------------

-// Take damage from being thrown by a physcannon 

-//-----------------------------------------------------------------------------

-#define MANHACK_SMASH_SPEED 500.0	// How fast a manhack must slam into something to take full damage

-void CNPC_Manhack::TakeDamageFromPhyscannon( CBasePlayer *pPlayer )

-{

-	CTakeDamageInfo info;

-	info.SetDamageType( DMG_GENERIC );

-	info.SetInflictor( this );

-	info.SetAttacker( pPlayer );

-	info.SetDamagePosition( GetAbsOrigin() );

-	info.SetDamageForce( Vector( 1.0, 1.0, 1.0 ) );

-

-	// Convert velocity into damage.

-	Vector vel;

-	VPhysicsGetObject()->GetVelocity( &vel, NULL );

-	float flSpeed = vel.Length();

-

-	float flFactor = flSpeed / MANHACK_SMASH_SPEED;

-

-	// Clamp. Don't inflict negative damage or massive damage!

-	flFactor = clamp( flFactor, 0.0f, 2.0f );

-	float flDamage = m_iMaxHealth * flFactor;

-

-#if 0

-	Msg("Doing %f damage for %f speed!\n", flDamage, flSpeed );

-#endif

-

-	info.SetDamage( flDamage );

-	TakeDamage( info );

-}

-

-

-//-----------------------------------------------------------------------------

-// Take damage from a vehicle; it's like a really big crowbar 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::TakeDamageFromVehicle( int index, gamevcollisionevent_t *pEvent )

-{

-	// Use the vehicle velocity to determine the damage

-	int otherIndex = !index;

-	CBaseEntity *pOther = pEvent->pEntities[otherIndex];

-

-	float flSpeed = pEvent->preVelocity[ otherIndex ].Length();

-	flSpeed = clamp( flSpeed, 300.0f, 600.0f );

-	float flDamage = SimpleSplineRemapVal( flSpeed, 300.0f, 600.0f, 0.0f, 1.0f );

-	if ( flDamage == 0.0f )

-		return;

-

-	flDamage *= 20.0f;

-

-	Vector damagePos;

-	pEvent->pInternalData->GetContactPoint( damagePos );

-

-	Vector damageForce = 2.0f * pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();

-	if ( damageForce == vec3_origin )

-	{

-		// This can happen if this entity is a func_breakable, and can't move.

-		// Use the velocity of the entity that hit us instead.

-		damageForce = 2.0f * pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();

-	}

-	Assert( damageForce != vec3_origin );

-	CTakeDamageInfo dmgInfo( pOther, pOther, damageForce, damagePos, flDamage, DMG_CRUSH );

-	TakeDamage( dmgInfo );

-}

-

-

-//-----------------------------------------------------------------------------

-// Take damage from combine ball

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent )

-{

-	CBaseEntity *pHitEntity = pEvent->pEntities[!index];

-

-	// NOTE: Bypass the normal impact energy scale here.

-	float flDamageScale = PlayerHasMegaPhysCannon() ? 10.0f : 1.0f;

-	int damageType = 0;

-	float damage = CalculateDefaultPhysicsDamage( index, pEvent, flDamageScale, true, damageType );

-	if ( damage == 0 )

-		return;

-

-	Vector damagePos;

-	pEvent->pInternalData->GetContactPoint( damagePos );

-	Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();

-	if ( damageForce == vec3_origin )

-	{

-		// This can happen if this entity is motion disabled, and can't move.

-		// Use the velocity of the entity that hit us instead.

-		damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();

-	}

-

-	// FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision

-	PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index );

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-#define MANHACK_SMASH_TIME	0.35		// How long after being thrown from a physcannon that a manhack is eligible to die from impact

-void CNPC_Manhack::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )

-{

-	BaseClass::VPhysicsCollision( index, pEvent );

-

-	// Take no impact damage while being carried.

-	if ( IsHeldByPhyscannon() )

-		return;

-

-	// Wake us up

-	if ( m_spawnflags & SF_MANHACK_PACKED_UP )

-	{

-		SetCondition( COND_LIGHT_DAMAGE );

-	}

-

-	int otherIndex = !index;

-	CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];

-

-	CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME );

-	if( pPlayer )

-	{

-		if (!pHitEntity)

-		{

-			TakeDamageFromPhyscannon( pPlayer );

-			StopBurst( true );

-			return;

-		}

-

-		// Don't take damage from NPCs or server ragdolls killed by the manhack

-		CRagdollProp *pRagdollProp = dynamic_cast<CRagdollProp*>(pHitEntity);

-		if (!pHitEntity->IsNPC() && (!pRagdollProp || pRagdollProp->GetKiller() != this))

-		{

-			TakeDamageFromPhyscannon( pPlayer );

-			StopBurst( true );

-			return;

-		}

-	}

-

-	if ( pHitEntity )

-	{

-		// It can take physics damage if it rams into a vehicle

-		if ( pHitEntity->GetServerVehicle() )

-		{

-			TakeDamageFromVehicle( index, pEvent );

-		}

-		else if ( pHitEntity->HasPhysicsAttacker( 0.5f ) )

-		{

-			// It also can take physics damage from things thrown by the player.

-			TakeDamageFromPhysicsImpact( index, pEvent );

-		}

-		else if ( FClassnameIs( pHitEntity, "prop_combine_ball" ) )

-		{

-			// It also can take physics damage from a combine ball.

-			TakeDamageFromPhysicsImpact( index, pEvent );

-		}

-		else if ( m_iHealth <= 0 )

-		{

-			TakeDamageFromPhysicsImpact( index, pEvent );

-		}

-

-		StopBurst( true );

-	}

-}

-

-

-void CNPC_Manhack::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent )

-{

-	int otherIndex = !index;

-	CBaseEntity *pOther = pEvent->pEntities[otherIndex];

-

-	if ( pOther->GetMoveType() == MOVETYPE_VPHYSICS )

-	{

-		HitPhysicsObject( pOther );

-	}

-	BaseClass::VPhysicsShadowCollision( index, pEvent );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Manhack is out of control! (dying) Just explode as soon as you touch anything!

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::CrashTouch( CBaseEntity *pOther )

-{

-	CTakeDamageInfo	info( GetWorldEntity(), GetWorldEntity(), 25, DMG_CRUSH );

-

-	CorpseGib( info );

-}

-

-

-//-----------------------------------------------------------------------------

-// Create smoke trail!

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::CreateSmokeTrail()

-{

-	if ( HasSpawnFlags( SF_MANHACK_NO_DAMAGE_EFFECTS ) )

-		return;

-

-	if ( m_hSmokeTrail != NULL )

-		return;

-

-	SmokeTrail *pSmokeTrail =  SmokeTrail::CreateSmokeTrail();

-	if( !pSmokeTrail )

-		return;

-

-	pSmokeTrail->m_SpawnRate = 20;

-	pSmokeTrail->m_ParticleLifetime = 0.5f;

-	pSmokeTrail->m_StartSize	= 8;

-	pSmokeTrail->m_EndSize		= 32;

-	pSmokeTrail->m_SpawnRadius	= 5;

-	pSmokeTrail->m_MinSpeed		= 15;

-	pSmokeTrail->m_MaxSpeed		= 25;

-	

-	pSmokeTrail->m_StartColor.Init( 0.4f, 0.4f, 0.4f );

-	pSmokeTrail->m_EndColor.Init( 0, 0, 0 );

-	

-	pSmokeTrail->SetLifetime(-1);

-	pSmokeTrail->FollowEntity(this);

-

-	m_hSmokeTrail = pSmokeTrail;

-}

-

-void CNPC_Manhack::DestroySmokeTrail()

-{

-	if ( m_hSmokeTrail.Get() )

-	{

-		UTIL_Remove( m_hSmokeTrail );

-		m_hSmokeTrail = NULL;

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-int	CNPC_Manhack::OnTakeDamage_Alive( const CTakeDamageInfo &info )

-{

-	// Hafta make a copy of info cause we might need to scale damage.(sjb)

-	CTakeDamageInfo tdInfo = info;

-

-	if( tdInfo.GetAmmoType() == GetAmmoDef()->Index("SniperRound") )

-	{

-		// Unfortunately, this is the easiest way to stop the sniper killing manhacks in one shot.

-		tdInfo.SetDamage( m_iMaxHealth>>1 );

-	}

-

-	if (info.GetDamageType() & DMG_PHYSGUN )

-	{

-		m_flBladeSpeed = 20.0;

-

-		// respond to physics

-		// FIXME: shouldn't this happen in a base class?  Anyway to prevent it from happening twice?

-		VPhysicsTakeDamage( info );

-

-		// reduce damage to nothing

-		tdInfo.SetDamage( 1.0 );

-

-		StopBurst( true );

-	}

-	else if ( info.GetDamageType() & DMG_AIRBOAT )

-	{

-		// Airboat gun kills me instantly.

-		tdInfo.SetDamage( GetHealth() );

-	}

-	else if (info.GetDamageType() & DMG_CLUB)

-	{

-		// Being hit by a club means a couple of things:

-		//

-		//		-I'm going to be knocked away from the person that clubbed me.

-		//		 if fudging this vector a little bit could help me slam into a physics object,

-		//		 then make that adjustment. This is a simple heuristic. The manhack will be

-		//		 directed towards the physics object that is closest to g_vecAttackDir

-		//

-

-		//		-Take 150% damage from club attacks. This makes crowbar duels take two hits.

-		

-		tdInfo.ScaleDamage( 1.50 );

-

-#define MANHACK_PHYS_SEARCH_SIZE		64

-#define	MANHACK_PHYSICS_SEARCH_RADIUS	128

-

-		CBaseEntity *pList[ MANHACK_PHYS_SEARCH_SIZE ];

-

-		Vector attackDir = info.GetDamageForce();

-		VectorNormalize( attackDir );

-

-		Vector testCenter = GetAbsOrigin() + ( attackDir * MANHACK_PHYSICS_SEARCH_RADIUS );

-		Vector vecDelta( MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS );

-

-		int count = UTIL_EntitiesInBox( pList, MANHACK_PHYS_SEARCH_SIZE, testCenter - vecDelta, testCenter + vecDelta, 0 );

-

-		Vector			vecBestDir = g_vecAttackDir;

-		float			flBestDot = 0.90;

-		IPhysicsObject	*pPhysObj;

-

-		int i;

-		for( i = 0 ; i < count ; i++ )

-		{

-			pPhysObj = pList[ i ]->VPhysicsGetObject();

-

-			if( !pPhysObj || pPhysObj->GetMass() > 200 )

-			{

-				// Not physics.

-				continue;

-			}

-

-			Vector center = pList[ i ]->WorldSpaceCenter();

-

-			Vector vecDirToObject;

-			VectorSubtract( center, WorldSpaceCenter(), vecDirToObject );

-			VectorNormalize( vecDirToObject );

-

-			float flDot;

-

-			flDot = DotProduct( g_vecAttackDir, vecDirToObject );

-			

-

-			if( flDot > flBestDot )

-			{

-				flBestDot = flDot;

-				vecBestDir = vecDirToObject;

-			}

-		}

-

-		tdInfo.SetDamageForce( vecBestDir * info.GetDamage() * 200 );

-

-		// FIXME: shouldn't this happen in a base class?  Anyway to prevent it from happening twice?

-		VPhysicsTakeDamage( tdInfo );

-

-		// Force us away (no more residual speed hits!)

-		m_vForceVelocity = vecBestDir * info.GetDamage() * 0.5f;

-		m_flBladeSpeed = 10.0;

-

-		EmitSound( "NPC_Manhack.Bat" );	

-

-		// tdInfo.SetDamage( 1.0 );

-

-		m_flEngineStallTime = gpGlobals->curtime + 0.5f;

-		StopBurst( true );

-	}

-	else

-	{

-		m_flBladeSpeed = 20.0;

-

-		Vector vecDamageDir = tdInfo.GetDamageForce();

-		VectorNormalize( vecDamageDir );

-

-		m_flEngineStallTime = gpGlobals->curtime + 0.25f;

-		m_vForceVelocity = vecDamageDir * info.GetDamage() * 20.0f;

-

-		tdInfo.SetDamageForce( tdInfo.GetDamageForce() * 20 );

-

-		VPhysicsTakeDamage( info );

-	}

-

-	int nRetVal = BaseClass::OnTakeDamage_Alive( tdInfo );

-	if ( nRetVal )

-	{

-		if ( m_iHealth > 0 )

-		{

-			if ( info.GetDamageType() & DMG_CLUB )

-			{

-				SetEyeState( MANHACK_EYE_STATE_STUNNED );

-			}

-

-			if ( m_iHealth <= ( m_iMaxHealth / 2 ) )

-			{

-				CreateSmokeTrail();

-			}

-		}

-		else

-		{

-			DestroySmokeTrail();

-		}

-	}

-

-	return nRetVal;

-}

-

-

-//------------------------------------------------------------------------------

-// Purpose:

-//------------------------------------------------------------------------------

-bool CNPC_Manhack::CorpseGib( const CTakeDamageInfo &info )

-{

-	Vector			vecGibVelocity;

-	AngularImpulse	vecGibAVelocity;

-

-	if( info.GetDamageType() & DMG_CLUB )

-	{

-		// If clubbed to death, break apart before the attacker's eyes!

-		vecGibVelocity = g_vecAttackDir * -150;

-

-		vecGibAVelocity.x = random->RandomFloat( -2000, 2000 );

-		vecGibAVelocity.y = random->RandomFloat( -2000, 2000 );

-		vecGibAVelocity.z = random->RandomFloat( -2000, 2000 );

-	}

-	else

-	{

-		// Shower the pieces with my velocity.

-		vecGibVelocity = GetCurrentVelocity();

-

-		vecGibAVelocity.x = random->RandomFloat( -500, 500 );

-		vecGibAVelocity.y = random->RandomFloat( -500, 500 );

-		vecGibAVelocity.z = random->RandomFloat( -500, 500 );

-	}

-

-	PropBreakableCreateAll( GetModelIndex(), NULL, GetAbsOrigin(), GetAbsAngles(), vecGibVelocity, vecGibAVelocity, 1.0, 60, COLLISION_GROUP_DEBRIS );

-

-	RemoveDeferred();

-

-	KillSprites( 0.0f );

-

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Explode the manhack if it's damaged while crashing

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-int	CNPC_Manhack::OnTakeDamage_Dying( const CTakeDamageInfo &info )

-{

-	// Ignore damage for the first 1 second of crashing behavior.

-	// If we don't do this, manhacks always just explode under 

-	// sustained fire.

-	VPhysicsTakeDamage( info );

-	

-	return 0;

-}

-

-//-----------------------------------------------------------------------------

-// Turn on the engine sound if we're gagged!

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::OnStateChange( NPC_STATE OldState, NPC_STATE NewState )

-{

-	if( m_vNoiseMod.z == MANHACK_NOISEMOD_HIDE && !(m_spawnflags & SF_NPC_WAIT_FOR_SCRIPT) && !(m_spawnflags & SF_MANHACK_PACKED_UP) )

-	{

-		// This manhack should get a normal noisemod now.

-		float flNoiseMod = random->RandomFloat( 1.7, 2.3 );

-		

-		// Just bob up and down.

-		SetNoiseMod( 0, 0, flNoiseMod );

-	}

-

-	if( NewState != NPC_STATE_IDLE && (m_spawnflags & SF_NPC_GAG) && (m_nEnginePitch1 < 0) )

-	{

-		m_spawnflags &= ~SF_NPC_GAG;

-		SoundInit();

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : Type - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::HandleAnimEvent( animevent_t *pEvent )

-{

-	Vector vecNewVelocity;

-	switch( pEvent->event )

-	{

-	case MANHACK_AE_START_ENGINE:

-		StartEye();

-		StartEngine( true );

-		m_spawnflags &= ~SF_MANHACK_PACKED_UP;

-

-		// No bursts until fully unpacked!

-		m_flNextBurstTime = gpGlobals->curtime + FLT_MAX;

-		break;

-

-	case MANHACK_AE_DONE_UNPACKING:

-		m_flNextBurstTime = gpGlobals->curtime + 2.0;

-		break;

-

-	case MANHACK_AE_OPEN_BLADE:

-		m_bBladesActive = true;

-		break;

-

-	default:

-		BaseClass::HandleAnimEvent( pEvent );

-		break;

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Returns whether or not the given activity would translate to flying.

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::IsFlyingActivity( Activity baseAct )

-{

-	return ((baseAct == ACT_FLY || baseAct == ACT_IDLE || baseAct == ACT_RUN || baseAct == ACT_WALK) && m_bBladesActive);

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : Type - 

-//-----------------------------------------------------------------------------

-Activity CNPC_Manhack::NPC_TranslateActivity( Activity baseAct )

-{

-	if (IsFlyingActivity( baseAct ))

-	{

-		return (Activity)ACT_FLY;

-	}

-

-	return BaseClass::NPC_TranslateActivity( baseAct );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : Type - 

-//-----------------------------------------------------------------------------

-int CNPC_Manhack::TranslateSchedule( int scheduleType ) 

-{

-	// Fail-safe for deployment if packed up and interrupted

-	if ( m_spawnflags & SF_MANHACK_PACKED_UP )

-	{

-		if ( scheduleType != SCHED_WAIT_FOR_SCRIPT )

-			return SCHED_MANHACK_DEPLOY;

-	}

-

-	switch ( scheduleType )

-	{

-	case SCHED_MELEE_ATTACK1:

-		{

-			return SCHED_MANHACK_ATTACK_HOVER;

-			break;

-		}

-	case SCHED_BACK_AWAY_FROM_ENEMY:

-		{

-			return SCHED_MANHACK_REGROUP;

-			break;

-		}

-	case SCHED_CHASE_ENEMY:

-		{

-			// If we're waiting for our next attack opportunity, just swarm

-			if ( m_flNextBurstTime > gpGlobals->curtime )

-			{

-				return SCHED_MANHACK_SWARM;

-			}

-

-			if ( !m_bDoSwarmBehavior || OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) )

-			{

-				return SCHED_CHASE_ENEMY;

-			}

-			else

-			{

-				return SCHED_MANHACK_SWARM;

-			}

-		}

-	case SCHED_COMBAT_FACE:

-		{

-			// Don't care about facing enemy, handled automatically

-			return TranslateSchedule( SCHED_CHASE_ENEMY );

-			break;

-		}

-	case SCHED_WAKE_ANGRY:

-		{

-			if( m_spawnflags & SF_MANHACK_PACKED_UP )

-			{

-				return SCHED_MANHACK_DEPLOY;

-			}

-			else

-			{

-				return TranslateSchedule( SCHED_CHASE_ENEMY );

-			}

-			break;

-		}

-

-	case SCHED_IDLE_STAND:

-	case SCHED_ALERT_STAND:

-	case SCHED_ALERT_FACE:

-		{

-			if ( m_pSquad && m_bDoSwarmBehavior )

-			{

-				return SCHED_MANHACK_SWARM_IDLE;

-			}

-			else

-			{

-				return BaseClass::TranslateSchedule(scheduleType);

-			}

-		}

-

-	case SCHED_CHASE_ENEMY_FAILED:

-		{

-			// Relentless bastard! Doesn't fail (fail not valid anyway)

-			return TranslateSchedule( SCHED_CHASE_ENEMY );

-			break;

-		}

-

-	}

-	return BaseClass::TranslateSchedule(scheduleType);

-}

-

-#define MAX_LOITER_DIST_SQR 144 // (12 inches sqr)

-void CNPC_Manhack::Loiter()

-{

-	//NDebugOverlay::Line( GetAbsOrigin(), m_vecLoiterPosition, 255, 255, 255, false, 0.1 );

-

-	// Friendly manhack is loitering.

-	if( !m_bHeld )

-	{

-		float distSqr = m_vecLoiterPosition.DistToSqr(GetAbsOrigin());

-

-		if( distSqr > MAX_LOITER_DIST_SQR )

-		{

-			Vector vecDir = m_vecLoiterPosition - GetAbsOrigin();

-			VectorNormalize( vecDir );

-

-			// Move back to our loiter position.

-			if( gpGlobals->curtime > m_fTimeNextLoiterPulse )

-			{

-				// Apply a pulse of force if allowed right now.

-				if( distSqr > MAX_LOITER_DIST_SQR * 4.0f )

-				{

-					//Msg("Big Pulse\n");

-					m_vForceVelocity = vecDir * 12.0f;

-				}

-				else

-				{

-					//Msg("Small Pulse\n");

-					m_vForceVelocity = vecDir * 6.0f;

-				}

-

-				m_fTimeNextLoiterPulse = gpGlobals->curtime + 1.0f;

-			}

-			else

-			{

-				m_vForceVelocity = vec3_origin;

-			}

-		}

-		else

-		{

-			// Counteract velocity to slow down.

-			Vector velocity = GetCurrentVelocity();

-			m_vForceVelocity = velocity * -0.5;

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::MaintainGroundHeight( void )

-{

-	float zSpeed = GetCurrentVelocity().z;

-

-	if ( zSpeed > 32.0f )

-		return;

-

-	const float minGroundHeight = 52.0f;

-

-	trace_t	tr;

-	AI_TraceHull(	GetAbsOrigin(), 

-		GetAbsOrigin() - Vector( 0, 0, minGroundHeight ), 

-		GetHullMins(), 

-		GetHullMaxs(), 

-		(MASK_NPCSOLID_BRUSHONLY), 

-		this, 

-		COLLISION_GROUP_NONE, 

-		&tr );

-

-	if ( tr.fraction != 1.0f )

-	{

-		float speedAdj = MAX( 16, (-zSpeed*0.5f) );

-

-		m_vForceVelocity += Vector(0,0,1) * ( speedAdj * ( 1.0f - tr.fraction ) );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Handles movement towards the last move target.

-// Input  : flInterval - 

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::OverrideMove( float flInterval )

-{

-	SpinBlades( flInterval );

-		

-	// Don't execute any move code if packed up.

-	if( HasSpawnFlags(SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED) )

-		return true;

-

-	if( IsLoitering() )

-	{

-		Loiter();

-	}

-	else

-	{

-		MaintainGroundHeight();

-	}

-

-	// So cops, etc. will try to avoid them

-	if ( !HasSpawnFlags( SF_MANHACK_NO_DANGER_SOUNDS ) && !m_bHeld )

-	{

-		CSoundEnt::InsertSound( SOUND_DANGER, GetAbsOrigin(), 75, flInterval, this );

-	}

-

-	// -----------------------------------------------------------------

-	//  If I'm being forced to move somewhere

-	// ------------------------------------------------------------------

-	if (m_fForceMoveTime > gpGlobals->curtime)

-	{

-		MoveToTarget(flInterval, m_vForceMoveTarget);

-	}

-	// -----------------------------------------------------------------

-	// If I have a route, keep it updated and move toward target

-	// ------------------------------------------------------------------

-	else if (GetNavigator()->IsGoalActive())

-	{

-		bool bReducible = GetNavigator()->GetPath()->GetCurWaypoint()->IsReducible();

-		const float strictTolerance = 64.0;

-		//NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, 10 ), 255, 0, 0, true, 0.1);

-  		if ( ProgressFlyPath( flInterval, GetEnemy(), MoveCollisionMask(), bReducible, strictTolerance ) == AINPP_COMPLETE )

-			return true;

-	}

-	// -----------------------------------------------------------------

-	// If I'm supposed to swarm somewhere, try to go there

-	// ------------------------------------------------------------------

-	else if (m_fSwarmMoveTime > gpGlobals->curtime)

-	{

-		MoveToTarget(flInterval, m_vSwarmMoveTarget);

-	}

-	// -----------------------------------------------------------------

-	// If I don't have anything better to do, just decelerate

-	// -------------------------------------------------------------- ----

-	else

-	{

-		float	myDecay	 = 9.5;

-		Decelerate( flInterval, myDecay );

-

-		m_vTargetBanking = vec3_origin;

-

-		// -------------------------------------

-		// If I have an enemy turn to face him

-		// -------------------------------------

-		if (GetEnemy())

-		{

-			TurnHeadToTarget(flInterval, GetEnemy()->EyePosition() );

-		}

-	}

-

-	if ( m_iHealth <= 0 )

-	{

-		// Crashing!!

-		MoveExecute_Dead(flInterval);

-	}

-	else

-	{

-		// Alive!

-		MoveExecute_Alive(flInterval);

-	}

-

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::TurnHeadRandomly(float flInterval )

-{

-	float desYaw = random->RandomFloat(0,360);

-

-	float	iRate	 = 0.8;

-	// Make frame rate independent

-	float timeToUse = flInterval;

-	while (timeToUse > 0)

-	{

-		m_fHeadYaw	   = (iRate * m_fHeadYaw) + (1-iRate)*desYaw;

-		timeToUse = -0.1;

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::MoveToTarget(float flInterval, const Vector &vMoveTarget)

-{

-	if (flInterval <= 0)

-	{

-		return;

-	}

-

-	// -----------------------------------------

-	// Don't steer if engine's have stalled

-	// -----------------------------------------

-	if ( gpGlobals->curtime < m_flEngineStallTime || m_iHealth <= 0 )

-		return;

-

-	if ( GetEnemy() != NULL )

-	{

-		TurnHeadToTarget( flInterval, GetEnemy()->EyePosition() );

-	}

-	else

-	{

-		TurnHeadToTarget( flInterval, vMoveTarget );

-	}

-

-	// -------------------------------------

-	// Move towards our target

-	// -------------------------------------

-	float	myAccel;

-	float	myZAccel = 300.0f;

-	float	myDecay	 = 0.3f;

-

-	Vector targetDir;

-	float flDist;

-

-	// If we're bursting, just head straight

-	if ( m_flBurstDuration > gpGlobals->curtime )

-	{

-		float zDist = 500;

-

-		// Steer towards our enemy if we're able to

-		if ( GetEnemy() != NULL )

-		{

-			Vector steerDir = ( GetEnemy()->EyePosition() - GetAbsOrigin() );

-			zDist = fabs( steerDir.z );

-			VectorNormalize( steerDir );

-

-			float useTime = flInterval;

-			while ( useTime > 0.0f )

-			{

-				m_vecBurstDirection += ( steerDir * 4.0f );

-				useTime -= 0.1f;

-			}

-

-			m_vecBurstDirection.z = steerDir.z;

-

-			VectorNormalize( m_vecBurstDirection );

-		}

-

-		// Debug visualizations

-		/*

-		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( targetDir * 64.0f ), 255, 0, 0, true, 2.1f );

-		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steerDir * 64.0f ), 0, 255, 0, true, 2.1f );

-		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( m_vecBurstDirection * 64.0f ), 0, 0, 255, true, 2.1f );

-		NDebugOverlay::Cross3D( GetAbsOrigin() , -Vector(8,8,8), Vector(8,8,8), 255, 0, 0, true, 2.1f );

-		*/

-

-		targetDir = m_vecBurstDirection;

-

-		flDist	= FLT_MAX;

-		myDecay	 = 0.3f;

-#ifdef _XBOX

-		myAccel	 = 500;

-#else

-		myAccel	 = 400;

-#endif // _XBOX

-		myZAccel = MIN( 500, zDist / flInterval );

-	}

-	else

-	{

-		Vector vecCurrentDir = GetCurrentVelocity();

-		VectorNormalize( vecCurrentDir );

-

-		targetDir = vMoveTarget - GetAbsOrigin();

-		flDist = VectorNormalize( targetDir );

-		

-		float flDot = DotProduct( targetDir, vecCurrentDir );

-

-		// Otherwise we should steer towards our goal

-		if( flDot > 0.25 )

-		{

-			// If my target is in front of me, my flight model is a bit more accurate.

-			myAccel = 300;

-		}

-		else

-		{

-			// Have a harder time correcting my course if I'm currently flying away from my target.

-			myAccel = 200;

-		}

-	}

-

-	// Clamp lateral acceleration

-	if ( myAccel > ( flDist / flInterval ) )

-	{

-		myAccel = flDist / flInterval;

-	}

-

-	/*

-	// Boost vertical movement

-	if ( targetDir.z > 0 )

-	{

-		// Z acceleration is faster when we thrust upwards.

-		// This is to help keep manhacks out of water. 

-		myZAccel *= 5.0;

-	}

-	*/

-

-	// Clamp vertical movement

-	if ( myZAccel > flDist / flInterval )

-	{

-		myZAccel = flDist / flInterval;

-	}

-

-	// Scale by our engine force

-	myAccel *= m_fEnginePowerScale;

-	myZAccel *= m_fEnginePowerScale;

-	

-	MoveInDirection( flInterval, targetDir, myAccel, myZAccel, myDecay );

-

-	// calc relative banking targets

-	Vector forward, right;

-	GetVectors( &forward, &right, NULL );

-	m_vTargetBanking.x	= 40 * DotProduct( forward, targetDir );

-	m_vTargetBanking.z	= 40 * DotProduct( right, targetDir );

-	m_vTargetBanking.y	= 0.0;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Ignore water if I'm close to my enemy

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-int CNPC_Manhack::MoveCollisionMask(void)

-{

-	return MASK_NPCSOLID;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Make a splash effect

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Splash( const Vector &vecSplashPos )

-{

-	CEffectData	data;

-

-	data.m_fFlags = 0;

-	data.m_vOrigin = vecSplashPos;

-	data.m_vNormal = Vector( 0, 0, 1 );

-

-	data.m_flScale = 8.0f;

-

-	int contents = GetWaterType();

-

-	// Verify we have valid contents

-	if ( !( contents & (CONTENTS_SLIME|CONTENTS_WATER)))

-	{

-		// We're leaving the water so we have to reverify what it was

-		trace_t	tr;

-		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 256 ), (CONTENTS_WATER|CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &tr );

-

-		// Re-validate this

-		if ( !(tr.contents&(CONTENTS_WATER|CONTENTS_SLIME)) )

-		{

-			//NOTENOTE: We called a splash but we don't seem to be near water?

-			Assert( 0 );

-			return;

-		}

-

-		contents = tr.contents;

-	}

-	

-	// Mark us if we're in slime

-	if ( contents & CONTENTS_SLIME )

-	{

-		data.m_fFlags |= FX_WATER_IN_SLIME;

-	}

-

-	DispatchEffect( "watersplash", data );

-}

-

-//-----------------------------------------------------------------------------

-// Computes the slice bounce velocity

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::ComputeSliceBounceVelocity( CBaseEntity *pHitEntity, trace_t &tr )

-{

-	if( pHitEntity->IsAlive() && FClassnameIs( pHitEntity, "func_breakable_surf" ) )

-	{

-		// We want to see if the manhack hits a breakable pane of glass. To keep from checking

-		// The classname of the HitEntity on each impact, we only do this check if we hit 

-		// something that's alive. Anyway, prevent the manhack bouncing off the pane of glass,

-		// since this impact will shatter the glass and let the manhack through.

-		return;

-	}

-

-	Vector vecDir;

-	

-	// If the manhack isn't bouncing away from whatever he sliced, force it.

-	VectorSubtract( WorldSpaceCenter(), pHitEntity->WorldSpaceCenter(), vecDir );

-	VectorNormalize( vecDir );

-	vecDir *= 200;

-	vecDir[2] = 0.0f;

-	

-	// Knock it away from us

-	if ( VPhysicsGetObject() != NULL )

-	{

-		VPhysicsGetObject()->ApplyForceOffset( vecDir * 4, GetAbsOrigin() );

-	}

-

-	// Also set our velocity

-	SetCurrentVelocity( vecDir );

-}

-

-

-//-----------------------------------------------------------------------------

-// Is the manhack being held?

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::IsHeldByPhyscannon( )

-{

-	return VPhysicsGetObject() && (VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD);

-}

-

-	

-//-----------------------------------------------------------------------------

-// Purpose: We've touched something that we can hurt. Slice it!

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Slice( CBaseEntity *pHitEntity, float flInterval, trace_t &tr )

-{

-	// Don't hurt the player if I'm in water

-	if( GetWaterLevel() > 0 && pHitEntity->IsPlayer() )

-		return;

-

-	// Can't slice players holding it with the phys cannon

-	if ( IsHeldByPhyscannon() )

-	{

-		if ( pHitEntity && (pHitEntity == HasPhysicsAttacker( FLT_MAX )) )

-			return;

-	}

-

-	if ( pHitEntity->m_takedamage == DAMAGE_NO )

-		return;

-

-	// Damage must be scaled by flInterval so framerate independent

-	float flDamage = sk_manhack_melee_dmg.GetFloat() * flInterval;

-

-	if ( pHitEntity->IsPlayer() )

-	{

-		flDamage *= 2.0f;

-	}

-	

-	// Held manhacks do more damage

-	if ( IsHeldByPhyscannon() )

-	{

-		// Deal 100 damage/sec

-		flDamage = 100.0f * flInterval;

-	}

-	else if ( pHitEntity->IsNPC() && HasPhysicsAttacker( MANHACK_SMASH_TIME ) )

-	{

-		extern ConVar sk_combine_guard_health;

-		// NOTE: The else here is essential.

-		// The physics attacker *will* be set even when the manhack is held

-		flDamage = sk_combine_guard_health.GetFloat(); // the highest healthed fleshy enemy

-	}

-	else if ( dynamic_cast<CBaseProp*>(pHitEntity) || dynamic_cast<CBreakable*>(pHitEntity) )

-	{

-		// If we hit a prop, we want it to break immediately

-		flDamage = pHitEntity->GetHealth();

-	}

-	else if ( pHitEntity->IsNPC() && IRelationType( pHitEntity ) == D_HT  && FClassnameIs( pHitEntity, "npc_combine_s" ) ) 

-	{

-		flDamage *= 6.0f;

-	}

-

-	if (flDamage < 1.0f)

-	{

-		flDamage = 1.0f;

-	}

-

-	CTakeDamageInfo info( this, this, flDamage, DMG_SLASH );

-

-	// check for actual "ownership" of damage

-	CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME );

-	if (pPlayer)

-	{

-		info.SetAttacker( pPlayer );

-	}

-

-	Vector dir = (tr.endpos - tr.startpos);

-	if ( dir == vec3_origin )

-	{

-		dir = tr.m_pEnt->GetAbsOrigin() - GetAbsOrigin();

-	}

-	CalculateMeleeDamageForce( &info, dir, tr.endpos );

-	pHitEntity->TakeDamage( info );

-

-	// Spawn some extra blood where we hit

-	if ( pHitEntity->BloodColor() == DONT_BLEED )

-	{

-		CEffectData data;

-		Vector velocity = GetCurrentVelocity();

-

-		data.m_vOrigin = tr.endpos;

-		data.m_vAngles = GetAbsAngles();

-

-		VectorNormalize( velocity );

-		

-		data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;;

-

-		DispatchEffect( "ManhackSparks", data );

-

-		EmitSound( "NPC_Manhack.Grind" );

-

-		//TODO: What we really want to do is get a material reference and emit the proper sprayage! - jdw

-	}

-	else

-	{

-		SpawnBlood(tr.endpos, g_vecAttackDir, pHitEntity->BloodColor(), 6 );

-		EmitSound( "NPC_Manhack.Slice" );

-	}

-

-	// Pop back a little bit after hitting the player

-	ComputeSliceBounceVelocity( pHitEntity, tr );

-

-	// Save off when we last hit something

-	m_flLastDamageTime = gpGlobals->curtime;

-

-	// Reset our state and give the player time to react

-	StopBurst( true );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: We've touched something solid. Just bump it.

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Bump( CBaseEntity *pHitEntity, float flInterval, trace_t &tr )

-{

-	if ( !VPhysicsGetObject() )

-		return;

-

-	// Surpressing this behavior

-	if ( m_flBumpSuppressTime > gpGlobals->curtime )

-		return;

-

-	if ( pHitEntity->GetMoveType() == MOVETYPE_VPHYSICS && pHitEntity->Classify()!=CLASS_MANHACK )

-	{

-		HitPhysicsObject( pHitEntity );

-	}

-

-	// We've hit something so deflect our velocity based on the surface

-	// norm of what we've hit

-	if (flInterval > 0)

-	{

-		float moveLen = ( (GetCurrentVelocity() * flInterval) * (1.0 - tr.fraction) ).Length();

-

-		Vector moveVec	= moveLen*tr.plane.normal/flInterval;

-

-		// If I'm totally dead, don't bounce me up

-		if (m_iHealth <=0 && moveVec.z > 0)

-		{

-			moveVec.z = 0;

-		}

-

-		// If I'm right over the ground don't push down

-		if (moveVec.z < 0)

-		{

-			float floorZ = GetFloorZ(GetAbsOrigin());

-			if (abs(GetAbsOrigin().z - floorZ) < 36)

-			{

-				moveVec.z = 0;

-			}

-		}

-

-		Vector myUp;

-		VPhysicsGetObject()->LocalToWorldVector( &myUp, Vector( 0.0, 0.0, 1.0 ) );

-

-		// plane must be something that could hit the blades

-		if (fabs( DotProduct( myUp, tr.plane.normal ) ) < 0.25 )

-		{

-			CEffectData data;

-			Vector velocity = GetCurrentVelocity();

-

-			data.m_vOrigin = tr.endpos;

-			data.m_vAngles = GetAbsAngles();

-

-			VectorNormalize( velocity );

-			

-			data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;;

-

-			DispatchEffect( "ManhackSparks", data );

-

-			CBroadcastRecipientFilter filter;

-

-			te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 50, 0.3, 150 );

-			

-			// add some spin, but only if we're not already going fast..

-			Vector vecVelocity;

-			AngularImpulse vecAngVelocity;

-			VPhysicsGetObject()->GetVelocity( &vecVelocity, &vecAngVelocity );

-			float flDot = DotProduct( myUp, vecAngVelocity );

-			if ( fabs(flDot) < 100 )

-			{

-				//AngularImpulse torque = myUp * (1000 - flDot * 10);

-				AngularImpulse torque = myUp * (1000 - flDot * 2);

-				VPhysicsGetObject()->ApplyTorqueCenter( torque );

-			}

-			

-			if (!(m_spawnflags	& SF_NPC_GAG))

-			{

-				EmitSound( "NPC_Manhack.Grind" );

-			}

-

-			// For decals and sparks we must trace a line in the direction of the surface norm

-			// that we hit.

-			trace_t	decalTrace;

-			AI_TraceLine( GetAbsOrigin(), GetAbsOrigin() - (tr.plane.normal * 24),MASK_SOLID, this, COLLISION_GROUP_NONE, &decalTrace );

-

-			if ( decalTrace.fraction != 1.0 )

-			{

-				// Leave decal only if colliding horizontally

-				if ((DotProduct(Vector(0,0,1),decalTrace.plane.normal)<0.5) && (DotProduct(Vector(0,0,-1),decalTrace.plane.normal)<0.5))

-				{

-					UTIL_DecalTrace( &decalTrace, "ManhackCut" );

-				}

-			}

-		}

-		

-		// See if we will not have a valid surface

-		if ( tr.allsolid || tr.startsolid )

-		{

-			// Build a fake reflection back along our current velocity because we can't know how to reflect off

-			// a non-existant surface! -- jdw

-

-			Vector vecRandomDir = RandomVector( -1.0f, 1.0f );

-			SetCurrentVelocity( vecRandomDir * 50.0f );

-			m_flBumpSuppressTime = gpGlobals->curtime + 0.5f;

-		}

-		else

-		{

-			// This is a valid hit and we can deflect properly

-			

-			VectorNormalize( moveVec );

-			float hitAngle = -DotProduct( tr.plane.normal, -moveVec );

-

-			Vector vReflection = 2.0 * tr.plane.normal * hitAngle + -moveVec;

-

-			float flSpeed = GetCurrentVelocity().Length();

-			SetCurrentVelocity( GetCurrentVelocity() + vReflection * flSpeed * 0.5f );

-		}

-	}

-

-	// -------------------------------------------------------------

-	// If I'm on a path check LOS to my next node, and fail on path

-	// if I don't have LOS.  Note this is the only place I do this,

-	// so the manhack has to collide before failing on a path

-	// -------------------------------------------------------------

-	if (GetNavigator()->IsGoalActive() && !(GetNavigator()->GetPath()->CurWaypointFlags() & bits_WP_TO_PATHCORNER) )

-	{

-		AIMoveTrace_t moveTrace;

-		GetMoveProbe()->MoveLimit( NAV_GROUND, GetAbsOrigin(), GetNavigator()->GetCurWaypointPos(), 

-			MoveCollisionMask(), GetEnemy(), &moveTrace );

-

-		if (IsMoveBlocked( moveTrace ) && 

-			!moveTrace.pObstruction->ClassMatches( GetClassname() ))

-		{

-			TaskFail(FAIL_NO_ROUTE);

-			GetNavigator()->ClearGoal();

-			return;

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::CheckCollisions(float flInterval)

-{

-	// Trace forward to see if I hit anything. But trace forward along the

-	// owner's view direction if you're being carried.

-	Vector vecTraceDir, vecCheckPos;

-	VPhysicsGetObject()->GetVelocity( &vecTraceDir, NULL );

-	vecTraceDir *= flInterval;

-	if ( IsHeldByPhyscannon() )

-	{

-		CBasePlayer *pCarrier = HasPhysicsAttacker( FLT_MAX );

-		if ( pCarrier )

-		{

-			if ( pCarrier->CollisionProp()->CalcDistanceFromPoint( WorldSpaceCenter() ) < 30 )

-			{

-				AngleVectors( pCarrier->EyeAngles(), &vecTraceDir, NULL, NULL );

-				vecTraceDir *= 40.0f;

-			}

-		}

-	}

-

-	VectorAdd( GetAbsOrigin(), vecTraceDir, vecCheckPos );

-	

-	trace_t			tr;

-	CBaseEntity*	pHitEntity = NULL;

-	

-	AI_TraceHull(	GetAbsOrigin(), 

-					vecCheckPos, 

-					GetHullMins(), 

-					GetHullMaxs(),

-					MoveCollisionMask(),

-					this,

-					COLLISION_GROUP_NONE,

-					&tr );

-

-	if ( (tr.fraction != 1.0 || tr.startsolid) && tr.m_pEnt)

-	{

-		PhysicsMarkEntitiesAsTouching( tr.m_pEnt, tr );

-		pHitEntity = tr.m_pEnt;

-

-		if( m_bHeld && tr.m_pEnt->MyNPCPointer() && tr.m_pEnt->MyNPCPointer()->IsPlayerAlly() )

-		{

-			// Don't slice Alyx when she approaches to hack. We need a better solution for this!!

-			//Msg("Ignoring!\n");

-			return;

-		}

-

-		if ( pHitEntity != NULL && 

-			 pHitEntity->m_takedamage == DAMAGE_YES && 

-			 pHitEntity->Classify() != CLASS_MANHACK && 

-			 gpGlobals->curtime > m_flWaterSuspendTime )

-		{

-			// Slice this thing

-			Slice( pHitEntity, flInterval, tr );

-			m_flBladeSpeed = 20.0;

-		}

-		else

-		{

-			// Just bump into this thing.

-			Bump( pHitEntity, flInterval, tr );

-			m_flBladeSpeed = 20.0;

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-#define tempTIME_STEP = 0.5;

-void CNPC_Manhack::PlayFlySound(void)

-{

-	float flEnemyDist;

-

-	if( GetEnemy() )

-	{

-		flEnemyDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length();

-	}

-	else

-	{

-		flEnemyDist = FLT_MAX;

-	}

-

-	if( m_spawnflags & SF_NPC_GAG )

-	{

-		// Quiet!

-		return;

-	}

-

-	if( m_flWaterSuspendTime > gpGlobals->curtime )

-	{

-		// Just went in water. Slow the motor!!

-		if( m_bDirtyPitch )

-		{

-			m_nEnginePitch1 = MANHACK_WATER_PITCH1;

-			m_flEnginePitch1Time = gpGlobals->curtime + 0.5f;

-			m_nEnginePitch2 = MANHACK_WATER_PITCH2;

-			m_flEnginePitch2Time = gpGlobals->curtime + 0.5f;

-			m_bDirtyPitch = false;

-		}

-	}

-	// Spin sound based on distance from enemy (unless we're crashing)

-	else if (GetEnemy() && IsAlive() )

-	{

-		if( flEnemyDist < MANHACK_PITCH_DIST1 )

-		{

-			// recalculate pitch.

-			int iPitch1, iPitch2;

-			float flDistFactor;

-

-			flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST1 ); 

-			iPitch1 = MANHACK_MIN_PITCH1 + ( ( MANHACK_MAX_PITCH1 - MANHACK_MIN_PITCH1 ) * flDistFactor); 

-

-			// NOTE: MANHACK_PITCH_DIST2 must be < MANHACK_PITCH_DIST1

-			flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST2 ); 

-			iPitch2 = MANHACK_MIN_PITCH2 + ( ( MANHACK_MAX_PITCH2 - MANHACK_MIN_PITCH2 ) * flDistFactor); 

-

-			m_nEnginePitch1 = iPitch1;

-			m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;

-			m_nEnginePitch2 = iPitch2;

-			m_flEnginePitch2Time = gpGlobals->curtime + 0.1f;

-

-			m_bDirtyPitch = true;

-		}

-		else if( m_bDirtyPitch )

-		{

-			m_nEnginePitch1 = MANHACK_MIN_PITCH1;

-			m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;

-			m_nEnginePitch2 = MANHACK_MIN_PITCH2;

-			m_flEnginePitch2Time = gpGlobals->curtime + 0.2f;

-			m_bDirtyPitch = false;

-		}

-	}

-	// If no enemy just play low sound

-	else if( IsAlive() && m_bDirtyPitch )

-	{

-		m_nEnginePitch1 = MANHACK_MIN_PITCH1;

-		m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;

-		m_nEnginePitch2 = MANHACK_MIN_PITCH2;

-		m_flEnginePitch2Time = gpGlobals->curtime + 0.2f;

-

-		m_bDirtyPitch = false;

-	}

-

-	// Play special engine every once in a while

-	if (gpGlobals->curtime > m_flNextEngineSoundTime && flEnemyDist < 48)

-	{

-		m_flNextEngineSoundTime	= gpGlobals->curtime + random->RandomFloat( 3.0, 10.0 );

-

-		EmitSound( "NPC_Manhack.EngineNoise" );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::MoveExecute_Alive(float flInterval)

-{

-	PhysicsCheckWaterTransition();

-

-	Vector	vCurrentVelocity = GetCurrentVelocity();

-

-	// FIXME: move this

-	VPhysicsGetObject()->Wake();

-

-	if( m_fEnginePowerScale < GetMaxEnginePower() && gpGlobals->curtime > m_flWaterSuspendTime )

-	{

-		// Power is low, and we're no longer stuck in water, so bring power up.

-		m_fEnginePowerScale += 0.05;

-	}

-

-	// ----------------------------------------------------------------------------------------

-	// Add time-coherent noise to the current velocity so that it never looks bolted in place.

-	// ----------------------------------------------------------------------------------------

-	float noiseScale = 7.0f;

-

-	if ( (CBaseEntity*)GetEnemy() )

-	{

-		float flDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length2D();

-

-		if( flDist < MANHACK_CHARGE_MIN_DIST )

-		{

-			// Less noise up close.

-			noiseScale = 2.0;

-		}

-

-		if ( IsInEffectiveTargetZone( GetEnemy() ) && flDist < MANHACK_CHARGE_MIN_DIST && gpGlobals->curtime > m_flNextBurstTime )

-		{

-			Vector vecCurrentDir = GetCurrentVelocity();

-			VectorNormalize( vecCurrentDir );

-

-			Vector vecToEnemy = ( GetEnemy()->EyePosition() - WorldSpaceCenter() );

-			VectorNormalize( vecToEnemy );

-

-			float flDot = DotProduct( vecCurrentDir, vecToEnemy );

-

-			if ( flDot > 0.75 )

-			{				

-				Vector offsetDir = ( vecToEnemy - vecCurrentDir );

-				VectorNormalize( offsetDir );

-

-				Vector offsetSpeed = GetCurrentVelocity() * flDot;

-

-				//FIXME: This code sucks -- jdw

-

-				offsetDir.z = 0.0f;

-				m_vForceVelocity += ( offsetDir * ( offsetSpeed.Length2D() * 0.25f ) );

-

-				// Commit to the attack- no steering for about a second

-				StartBurst( vecToEnemy );

-				SetEyeState( MANHACK_EYE_STATE_CHARGE );

-			}

-		}

-		

-		if ( gpGlobals->curtime > m_flBurstDuration )

-		{

-			ShowHostile( false );

-		}

-	}

-

-	// ----------------------------------------------------------------------------------------

-	// Add in any forced velocity

-	// ----------------------------------------------------------------------------------------

-	SetCurrentVelocity( vCurrentVelocity + m_vForceVelocity );

-	m_vForceVelocity = vec3_origin;

-

-	if( !m_bHackedByAlyx || GetEnemy() )

-	{

-		// If hacked and no enemy, don't drift!

-		AddNoiseToVelocity( noiseScale );

-	}

-

-	LimitSpeed( 200, ManhackMaxSpeed() );

-

-	if( m_flWaterSuspendTime > gpGlobals->curtime )

-	{ 

-		if( UTIL_PointContents( GetAbsOrigin() ) & (CONTENTS_WATER|CONTENTS_SLIME) )

-		{

-			// Ooops, we're submerged somehow. Move upwards until our origin is out of the water.

-			m_vCurrentVelocity.z = 20.0;

-		}

-		else

-		{

-			// Skimming the surface. Forbid any movement on Z

-			m_vCurrentVelocity.z = 0.0;

-		}

-	}

-	else if( GetWaterLevel() > 0 )

-	{

-		// Allow the manhack to lift off, but not to go deeper.

-		m_vCurrentVelocity.z = MAX( m_vCurrentVelocity.z, 0 );

-	}

-

-	CheckCollisions(flInterval);

-

-	// Blend out desired velocity when launched by the physcannon

-	if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) && (!IsHeldByPhyscannon()) && VPhysicsGetObject() )

-	{

-		Vector vecCurrentVelocity;

-		VPhysicsGetObject()->GetVelocity( &vecCurrentVelocity, NULL );

-		float flLerpFactor = (gpGlobals->curtime - m_flLastPhysicsInfluenceTime) / MANHACK_SMASH_TIME;

-		flLerpFactor = clamp( flLerpFactor, 0.0f, 1.0f );

-		flLerpFactor = SimpleSplineRemapVal( flLerpFactor, 0.0f, 1.0f, 0.0f, 1.0f );

-		VectorLerp( vecCurrentVelocity, m_vCurrentVelocity, flLerpFactor, m_vCurrentVelocity );

-	}

-

-	QAngle angles = GetLocalAngles();

-

-	// ------------------------------------------

-	//  Stalling

-	// ------------------------------------------

-	if (gpGlobals->curtime < m_flEngineStallTime)

-	{

-		/*

-		// If I'm stalled add random noise

-		angles.x += -20+(random->RandomInt(-10,10));

-		angles.z += -20+(random->RandomInt(0,40));

-

-		TurnHeadRandomly(flInterval);

-		*/

-	}

-	else

-	{

-		// Make frame rate independent

-		float	iRate	 = 0.5;

-		float timeToUse = flInterval;

-		while (timeToUse > 0)

-		{

-			m_vCurrentBanking.x = (iRate * m_vCurrentBanking.x) + (1 - iRate)*(m_vTargetBanking.x);

-			m_vCurrentBanking.z = (iRate * m_vCurrentBanking.z) + (1 - iRate)*(m_vTargetBanking.z);

-			timeToUse = -0.1;

-		}

-		angles.x = m_vCurrentBanking.x;

-		angles.z = m_vCurrentBanking.z;

-		angles.y = 0;

-

-#if 0

-		// Using our steering if we're not otherwise affecting our panels

-		if ( m_flEngineStallTime < gpGlobals->curtime && m_flBurstDuration < gpGlobals->curtime )

-		{

-			Vector delta( 10 * AngleDiff( m_vTargetBanking.x, m_vCurrentBanking.x ), -10 * AngleDiff( m_vTargetBanking.z, m_vCurrentBanking.z ), 0 );

-			//Vector delta( 3 * AngleNormalize( m_vCurrentBanking.x ), -4 * AngleNormalize( m_vCurrentBanking.z ), 0 );

-			VectorYawRotate( delta, -m_fHeadYaw, delta );

-

-			// DevMsg("%.0f %.0f\n", delta.x, delta.y );

-

-			SetPoseParameter( m_iPanel1, -delta.x - delta.y * 2);

-			SetPoseParameter( m_iPanel2, -delta.x + delta.y * 2);

-			SetPoseParameter( m_iPanel3,  delta.x + delta.y * 2);

-			SetPoseParameter( m_iPanel4,  delta.x - delta.y * 2);

-

-			//SetPoseParameter( m_iPanel1, -delta.x );

-			//SetPoseParameter( m_iPanel2, -delta.x );

-			//SetPoseParameter( m_iPanel3, delta.x );

-			//SetPoseParameter( m_iPanel4, delta.x );

-		}

-#endif

-	}

-

-	// SetLocalAngles( angles );

-

-	if( m_lifeState != LIFE_DEAD )

-	{

-		PlayFlySound();

-		// SpinBlades( flInterval );

-		// WalkMove( GetCurrentVelocity() * flInterval, MASK_NPCSOLID );

-	}

-

-//	 NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, -10 ), 0, 255, 0, true, 0.1);

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::SpinBlades(float flInterval)

-{

-	if (!m_bBladesActive)

-	{

-		SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF );

-		SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );

-		m_flBladeSpeed = 0.0;

-		m_flPlaybackRate = 1.0;

-		return;

-	}

-

-	if ( IsFlyingActivity( GetActivity() ) )

-	{

-		// Blades may only ramp up while the engine is running

-		if ( m_flEngineStallTime < gpGlobals->curtime )

-		{

-			if (m_flBladeSpeed < 10)

-			{

-				m_flBladeSpeed = m_flBladeSpeed * 2 + 1;

-			}

-			else

-			{

-				// accelerate engine

-				m_flBladeSpeed = m_flBladeSpeed + 80 * flInterval;

-			}

-		}

-

-		if (m_flBladeSpeed > 100)

-		{

-			m_flBladeSpeed = 100;

-		}

-

-		// blend through blades, blades+blur, blur

-		if (m_flBladeSpeed < 20)

-		{

-			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON );

-			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );

-		}

-		else if (m_flBladeSpeed < 40)

-		{

-			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON );

-			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON );

-		}

-		else

-		{

-			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF );

-			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON );

-		}

-

-		m_flPlaybackRate = m_flBladeSpeed / 100.0;

-	}

-	else

-	{

-		m_flBladeSpeed = 0.0;

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Smokes and sparks, exploding periodically. Eventually it goes away.

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::MoveExecute_Dead(float flInterval)

-{

-	if( GetWaterLevel() > 0 )

-	{

-		// No movement if sinking in water.

-		return;

-	}

-

-	// Periodically emit smoke.

-	if (gpGlobals->curtime > m_fSmokeTime && GetWaterLevel() == 0)

-	{

-//		UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10);

-		m_fSmokeTime = gpGlobals->curtime + random->RandomFloat( 0.1, 0.3);

-	}

-

-	// Periodically emit sparks.

-	if (gpGlobals->curtime > m_fSparkTime)

-	{

-		g_pEffects->Sparks( GetAbsOrigin() );

-		m_fSparkTime = gpGlobals->curtime + random->RandomFloat(0.1, 0.3);

-	}

-

-	Vector newVelocity = GetCurrentVelocity();

-

-	// accelerate faster and faster when dying

-	newVelocity = newVelocity + (newVelocity * 1.5 * flInterval );

-

-	// Lose lift

-	newVelocity.z -= 0.02*flInterval*(GetCurrentGravity());

-

-	// ----------------------------------------------------------------------------------------

-	// Add in any forced velocity

-	// ----------------------------------------------------------------------------------------

-	newVelocity += m_vForceVelocity;

-	SetCurrentVelocity( newVelocity );

-	m_vForceVelocity = vec3_origin;

-

-

-	// Lots of noise!! Out of control!

-	AddNoiseToVelocity( 5.0 );

-

-

-	// ----------------------

-	// Limit overall speed

-	// ----------------------

-	LimitSpeed( -1, MANHACK_MAX_SPEED * 2.0 );

-

-	QAngle angles = GetLocalAngles();

-

-	// ------------------------------------------

-	// If I'm dying, add random banking noise

-	// ------------------------------------------

-	angles.x += -20+(random->RandomInt(0,40));

-	angles.z += -20+(random->RandomInt(0,40));

-

-	CheckCollisions(flInterval);

-	PlayFlySound();

-

-	// SetLocalAngles( angles );

-

-	WalkMove( GetCurrentVelocity() * flInterval,MASK_NPCSOLID );

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Precache(void)

-{

-	//

-	// Model.

-	//

-	PrecacheModel("models/manhack.mdl");

-	PrecacheModel( MANHACK_GLOW_SPRITE );

-	PropBreakablePrecacheAll( MAKE_STRING("models/manhack.mdl") );

-	

-	PrecacheScriptSound( "NPC_Manhack.Die" );

-	PrecacheScriptSound( "NPC_Manhack.Bat" );

-	PrecacheScriptSound( "NPC_Manhack.Grind" );

-	PrecacheScriptSound( "NPC_Manhack.Slice" );

-	PrecacheScriptSound( "NPC_Manhack.EngineNoise" );

-	PrecacheScriptSound( "NPC_Manhack.Unpack" );

-	PrecacheScriptSound( "NPC_Manhack.ChargeAnnounce" );

-	PrecacheScriptSound( "NPC_Manhack.ChargeEnd" );

-	PrecacheScriptSound( "NPC_Manhack.Stunned" );

-

-	// Sounds used on Client:

-	PrecacheScriptSound( "NPC_Manhack.EngineSound1" );

-	PrecacheScriptSound( "NPC_Manhack.EngineSound2"  );

-	PrecacheScriptSound( "NPC_Manhack.BladeSound" );

-

-	BaseClass::Precache();

-}

-

-//-----------------------------------------------------------------------------

-// Purpose:

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::GatherEnemyConditions( CBaseEntity *pEnemy )

-{

-	// The Manhack "regroups" when its in attack range but to

-	// far above or below its enemy.  Set the start attack

-	// condition if we are far enough away from the enemy

-	// or at the correct height

-

-	// Don't bother with Z if the enemy is in a vehicle

-	float fl2DDist = 60.0f;

-	float flZDist = 12.0f;

-

-	if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() )

-	{

-		flZDist = 24.0f;

-	}

-

-	if ((GetAbsOrigin() - pEnemy->GetAbsOrigin()).Length2D() > fl2DDist) 

-	{

-		SetCondition(COND_MANHACK_START_ATTACK);

-	}

-	else

-	{

-		float targetZ	= pEnemy->EyePosition().z;

-		if (fabs(GetAbsOrigin().z - targetZ) < flZDist)

-		{

-			SetCondition(COND_MANHACK_START_ATTACK);

-		}

-	}

-	BaseClass::GatherEnemyConditions(pEnemy);

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: For innate melee attack

-// Input  :

-// Output :

-//-----------------------------------------------------------------------------

-int CNPC_Manhack::MeleeAttack1Conditions( float flDot, float flDist )

-{

-	if ( GetEnemy() == NULL )

-		return COND_NONE;

-

-	//TODO: We could also decide if we want to back up here

-	if ( m_flNextBurstTime > gpGlobals->curtime )

-		return COND_NONE;

-

-	float flMaxDist = 45;

-	float flMinDist = 24;

-	bool bEnemyInVehicle = GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle();

-	if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() )

-	{

-		flMinDist = 0;

-		flMaxDist = 200.0f;

-	}

-

-	if (flDist > flMaxDist)

-	{

-		return COND_TOO_FAR_TO_ATTACK;

-	}

-

-	if (flDist < flMinDist)

-	{

-		return COND_TOO_CLOSE_TO_ATTACK;

-	}

-

-	// Check our current velocity and speed, if it's too far off, we need to settle

-

-	// Don't bother with Z if the enemy is in a vehicle

-	if ( bEnemyInVehicle )

-	{

-		return COND_CAN_MELEE_ATTACK1;

-	}

-

-	// Assume the this check is in regards to my current enemy

-	// for the Manhacks spetial condition

-	float deltaZ = GetAbsOrigin().z - GetEnemy()->EyePosition().z;

-	if ( (deltaZ > 12.0f) || (deltaZ < -24.0f) )

-	{

-		return COND_TOO_CLOSE_TO_ATTACK;

-	}

-

-	return COND_CAN_MELEE_ATTACK1;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : *pTask - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::RunTask( const Task_t *pTask )

-{

-	switch ( pTask->iTask )

-	{

-		// Override this task so we go for the enemy at eye level

-	case TASK_MANHACK_HOVER:

-		{

-			break;

-		}

-

-	// If my enemy has moved significantly, update my path

-	case TASK_WAIT_FOR_MOVEMENT:

-		{

-			CBaseEntity *pEnemy = GetEnemy();

-			if (pEnemy &&

-				(GetCurSchedule()->GetId() == SCHED_CHASE_ENEMY) && 

-				GetNavigator()->IsGoalActive() )

-			{

-				Vector vecEnemyPosition;

-				vecEnemyPosition = pEnemy->EyePosition();

-				if ( GetNavigator()->GetGoalPos().DistToSqr(vecEnemyPosition) > 40 * 40 )

-				{

-					GetNavigator()->UpdateGoalPos( vecEnemyPosition );

-				}

-			}				

-			BaseClass::RunTask(pTask);

-			break;

-		}

-

-	case TASK_MANHACK_MOVEAT_SAVEPOSITION:

-		{

-			// do the movement thingy

-

-//			NDebugOverlay::Line( GetAbsOrigin(), m_vSavePosition, 0, 255, 0, true, 0.1);

-

-			Vector dir = (m_vSavePosition - GetAbsOrigin());

-			float dist = VectorNormalize( dir );

-			float t = m_fSwarmMoveTime - gpGlobals->curtime;

-

-			if (t < 0.1)

-			{

-				if (dist > 256)

-				{

-					TaskFail( FAIL_NO_ROUTE );

-				}

-				else

-				{

-					TaskComplete();

-				}

-			}

-			else if (dist < 64)

-			{

-				m_vSwarmMoveTarget = GetAbsOrigin() - Vector( -dir.y, dir.x, 0 ) * 4;

-			}

-			else

-			{

-				m_vSwarmMoveTarget = GetAbsOrigin() + dir * 10;

-			}

-			break;

-		}

-

-	default:

-		{

-			BaseClass::RunTask(pTask);

-		}

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::Spawn(void)

-{

-	Precache();

-

-#ifdef _XBOX

-	// Always fade the corpse

-	AddSpawnFlags( SF_NPC_FADE_CORPSE );

-#endif // _XBOX

-

-	SetModel( "models/manhack.mdl" );

-	SetHullType(HULL_TINY_CENTERED); 

-	SetHullSizeNormal();

-

-	SetSolid( SOLID_BBOX );

-	AddSolidFlags( FSOLID_NOT_STANDABLE );

-

-	if ( HasSpawnFlags( SF_MANHACK_CARRIED ) )

-	{

-		AddSolidFlags( FSOLID_NOT_SOLID );

-		SetMoveType( MOVETYPE_NONE );

-	}

-	else

-	{

-		SetMoveType( MOVETYPE_VPHYSICS );

-	}

-

-	m_iHealth			= sk_manhack_health.GetFloat();

-	SetViewOffset( Vector(0, 0, 10) );		// Position of the eyes relative to NPC's origin.

-	m_flFieldOfView		= VIEW_FIELD_FULL;

-	m_NPCState			= NPC_STATE_NONE;

-

-	if ( m_spawnflags & SF_MANHACK_USE_AIR_NODES)

-	{

-		SetNavType(NAV_FLY);

-	}

-	else

-	{

-		SetNavType(NAV_GROUND);

-	}

-		 

-	AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL );

-	AddEffects( EF_NOSHADOW );

-

-	SetBloodColor( DONT_BLEED );

-	SetCurrentVelocity( vec3_origin );

-	m_vForceVelocity.Init();

-	m_vCurrentBanking.Init();

-	m_vTargetBanking.Init();

-

-	m_flNextBurstTime	= gpGlobals->curtime;

-

-	CapabilitiesAdd( bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_MOVE_FLY | bits_CAP_SQUAD );

-

-	m_flNextEngineSoundTime		= gpGlobals->curtime;

-	m_flWaterSuspendTime		= gpGlobals->curtime;

-	m_flEngineStallTime			= gpGlobals->curtime;

-	m_fForceMoveTime			= gpGlobals->curtime;

-	m_vForceMoveTarget			= vec3_origin;

-	m_fSwarmMoveTime			= gpGlobals->curtime;

-	m_vSwarmMoveTarget			= vec3_origin;

-	m_nLastSpinSound			= -1;

-

-	m_fSmokeTime		= 0;

-	m_fSparkTime		= 0;

-

-	// Set the noise mod to huge numbers right now, in case this manhack starts out waiting for a script

-	// for instance, we don't want him to bob whilst he's waiting for a script. This allows designers

-	// to 'hide' manhacks in small places. (sjb)

-	SetNoiseMod( MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE );

-

-	// Start out with full power! 

-	m_fEnginePowerScale = GetMaxEnginePower();

-	

-	// find panels

-	m_iPanel1 = LookupPoseParameter( "Panel1" );

-	m_iPanel2 = LookupPoseParameter( "Panel2" );

-	m_iPanel3 = LookupPoseParameter( "Panel3" );

-	m_iPanel4 = LookupPoseParameter( "Panel4" );

-

-	m_fHeadYaw			= 0;

-

-	NPCInit();

-

-	// Manhacks are designed to slam into things, so don't take much damage from it!

-	SetImpactEnergyScale( 0.001 );

-

-	// Manhacks get 30 seconds worth of free knowledge.

-	GetEnemies()->SetFreeKnowledgeDuration( 30.0 );

-	

-	// don't be an NPC, we want to collide with debris stuff

-	SetCollisionGroup( COLLISION_GROUP_NONE );

-

-	m_bHeld = false;

-	m_bHackedByAlyx = false;

-	StopLoitering();

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StartEye( void )

-{

-	//Create our Eye sprite

-	if ( m_pEyeGlow == NULL )

-	{

-		m_pEyeGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false );

-		m_pEyeGlow->SetAttachment( this, LookupAttachment( "Eye" ) );

-		

-		if( m_bHackedByAlyx )

-		{

-			m_pEyeGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation );

-			m_pEyeGlow->SetColor( 0, 255, 0 );

-		}

-		else

-		{

-			m_pEyeGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );

-			m_pEyeGlow->SetColor( 255, 0, 0 );

-		}

-

-		m_pEyeGlow->SetBrightness( 164, 0.1f );

-		m_pEyeGlow->SetScale( 0.25f, 0.1f );

-		m_pEyeGlow->SetAsTemporary();

-	}

-

-	//Create our light sprite

-	if ( m_pLightGlow == NULL )

-	{

-		m_pLightGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false );

-		m_pLightGlow->SetAttachment( this, LookupAttachment( "Light" ) );

-

-		if( m_bHackedByAlyx )

-		{

-			m_pLightGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation );

-			m_pLightGlow->SetColor( 0, 255, 0 );

-		}

-		else

-		{

-			m_pLightGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );

-			m_pLightGlow->SetColor( 255, 0, 0 );

-		}

-

-		m_pLightGlow->SetBrightness( 164, 0.1f );

-		m_pLightGlow->SetScale( 0.25f, 0.1f );

-		m_pLightGlow->SetAsTemporary();

-	}

-}

-

-//-----------------------------------------------------------------------------

-

-void CNPC_Manhack::Activate()

-{

-	BaseClass::Activate();

-

-	if ( IsAlive() )

-	{

-		StartEye();

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Get the engine sound started. Unless we're not supposed to have it on yet!

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::PostNPCInit( void )

-{

-	// SetAbsVelocity( vec3_origin ); 

-	m_bBladesActive = (m_spawnflags & (SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED)) ? false : true;

-	BladesInit();

-}

-

-void CNPC_Manhack::BladesInit()

-{

-	if( !m_bBladesActive )

-	{

-		// manhack is packed up, so has no power of its own. 

-		// don't start the engine sounds.

-		// make us fall a little slower than we should, for visual's sake

-		SetGravity( UTIL_ScaleForGravity( 400 ) );

-

-		SetActivity( ACT_IDLE );

-	}

-	else

-	{

-		bool engineSound = (m_spawnflags & SF_NPC_GAG) ? false : true;

-		StartEngine( engineSound );

-		SetActivity( ACT_FLY );

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Crank up the engine!

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StartEngine( bool fStartSound )

-{

-	if( fStartSound )

-	{

-		SoundInit();

-	}

-

-	// Make the blade appear.

-	SetBodygroup( 1, 1 );

-

-	// Pop up a little if falling fast!

-	Vector vecVelocity;

-	GetVelocity( &vecVelocity, NULL );

-	if( ( m_spawnflags & SF_MANHACK_PACKED_UP ) && vecVelocity.z < 0 )

-	{

-		// DevMsg(" POP UP \n" );

-		// ApplyAbsVelocityImpulse( Vector(0,0,-vecVelocity.z*0.75) );

-	}

-

-	// Under powered flight now.

-	// SetMoveType( MOVETYPE_STEP );

-	// SetGravity( MANHACK_GRAVITY );

-	AddFlag( FL_FLY );

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: Start the manhack's engine sound.

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::SoundInit( void )

-{

-	m_nEnginePitch1 = MANHACK_MIN_PITCH1;

-	m_flEnginePitch1Time = gpGlobals->curtime;

-	m_nEnginePitch2 = MANHACK_MIN_PITCH2;

-	m_flEnginePitch2Time = gpGlobals->curtime;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StopLoopingSounds(void)

-{

-	BaseClass::StopLoopingSounds();

-	m_nEnginePitch1 = -1;

-	m_flEnginePitch1Time = gpGlobals->curtime;

-	m_nEnginePitch2 = -1;

-	m_flEnginePitch2Time = gpGlobals->curtime;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : pTask - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StartTask( const Task_t *pTask )

-{

-	switch (pTask->iTask)

-	{	

-	case TASK_MANHACK_UNPACK:

-		{

-			// Just play a sound for now.

-			EmitSound( "NPC_Manhack.Unpack" );

-

-			TaskComplete();

-		}

-		break;

-

-	case TASK_MANHACK_HOVER:

-		break;

-

-	case TASK_MOVE_TO_TARGET_RANGE:

-	case TASK_GET_PATH_TO_GOAL:

-	case TASK_GET_PATH_TO_ENEMY_LKP:

-	case TASK_GET_PATH_TO_PLAYER:

-		{

-			BaseClass::StartTask( pTask );

-			/*

-			// FIXME: why were these tasks considered bad?

-			_asm

-			{

-				int	3;

-				int 5;

-			}

-			*/

-		}

-		break;

-

-	case TASK_FACE_IDEAL:

-		{

-			// this shouldn't ever happen, but if it does, don't choke

-			TaskComplete();

-		}

-		break;

-

-	case TASK_GET_PATH_TO_ENEMY:

-		{

-			if (IsUnreachable(GetEnemy()))

-			{

-				TaskFail(FAIL_NO_ROUTE);

-				return;

-			}

-

-			CBaseEntity *pEnemy = GetEnemy();

-

-			if ( pEnemy == NULL )

-			{

-				TaskFail(FAIL_NO_ENEMY);

-				return;

-			}

-						

-			if ( GetNavigator()->SetGoal( GOALTYPE_ENEMY ) )

-			{

-				TaskComplete();

-			}

-			else

-			{

-				// no way to get there =( 

-				DevWarning( 2, "GetPathToEnemy failed!!\n" );

-				RememberUnreachable(GetEnemy());

-				TaskFail(FAIL_NO_ROUTE);

-			}

-			break;

-		}

-		break;

-

-	case TASK_GET_PATH_TO_TARGET:

-		// DevMsg("TARGET\n");

-		BaseClass::StartTask( pTask );

-		break;

-

-	case TASK_MANHACK_FIND_SQUAD_CENTER:

-		{

-			if (!m_pSquad)

-			{

-				m_vSavePosition = GetAbsOrigin();

-				TaskComplete();

-				break;

-			}

-

-			// calc center of squad

-			int count = 0;

-			m_vSavePosition = Vector( 0, 0, 0 );

-

-			// give attacking members more influence

-			AISquadIter_t iter;

-			for (CAI_BaseNPC *pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) )

-			{

-				if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ))

-				{

-					m_vSavePosition += pSquadMember->GetAbsOrigin() * 10;

-					count += 10;

-				}

-				else

-				{

-					m_vSavePosition += pSquadMember->GetAbsOrigin();

-					count++;

-				}

-			}

-

-			// pull towards enemy

-			if (GetEnemy() != NULL)

-			{

-				m_vSavePosition += GetEnemyLKP() * 4;

-				count += 4;

-			}

-

-			Assert( count != 0 );

-			m_vSavePosition = m_vSavePosition * (1.0 / count);

-

-			TaskComplete();

-		}

-		break;

-

-	case TASK_MANHACK_FIND_SQUAD_MEMBER:

-		{

-			if (m_pSquad)

-			{

-				CAI_BaseNPC *pSquadMember = m_pSquad->GetAnyMember();

-				m_vSavePosition = pSquadMember->GetAbsOrigin();

-

-				// find attacking members

-				AISquadIter_t iter;

-				for (pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) )

-				{

-					// are they attacking?

-					if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ))

-					{

-						m_vSavePosition = pSquadMember->GetAbsOrigin();

-						break;

-					}

-					// do they have a goal?

-					if (pSquadMember->GetNavigator()->IsGoalActive())

-					{

-						m_vSavePosition = pSquadMember->GetAbsOrigin();

-						break;

-					}

-				}

-			}

-			else

-			{

-				m_vSavePosition = GetAbsOrigin();

-			}

-

-			TaskComplete();

-		}

-		break;

-

-	case TASK_MANHACK_MOVEAT_SAVEPOSITION:

-		{

-			trace_t tr;

-			AI_TraceLine( GetAbsOrigin(), m_vSavePosition, MASK_NPCWORLDSTATIC, this, COLLISION_GROUP_NONE, &tr );

-			if (tr.DidHitWorld())

-			{

-				TaskFail( FAIL_NO_ROUTE );

-			}

-			else

-			{

-				m_fSwarmMoveTime = gpGlobals->curtime + RandomFloat( pTask->flTaskData * 0.8, pTask->flTaskData * 1.2 );

-			}

-		}

-		break;

-

-	default:

-		BaseClass::StartTask(pTask);

-		break;

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::UpdateOnRemove( void )

-{

-	DestroySmokeTrail();

-	KillSprites( 0.0 );

-	BaseClass::UpdateOnRemove();

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose:  This is a generic function (to be implemented by sub-classes) to

-//			 handle specific interactions between different types of characters

-//			 (For example the barnacle grabbing an NPC)

-// Input  :  Constant for the type of interaction

-// Output :	 true  - if sub-class has a response for the interaction

-//			 false - if sub-class has no response

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::HandleInteraction(int interactionType, void* data, CBaseCombatCharacter* sourceEnt)

-{

-	if (interactionType == g_interactionVortigauntClaw)

-	{

-		// Freeze so vortigaunt and hit me easier

-

-		m_vForceMoveTarget.x = ((Vector *)data)->x;

-		m_vForceMoveTarget.y = ((Vector *)data)->y;

-		m_vForceMoveTarget.z = ((Vector *)data)->z;

-		m_fForceMoveTime   = gpGlobals->curtime + 2.0;

-		return false;

-	}

-

-	return false;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Output : float

-//-----------------------------------------------------------------------------

-float CNPC_Manhack::ManhackMaxSpeed( void )

-{

-	if( m_flWaterSuspendTime > gpGlobals->curtime )

-	{

-		// Slower in water!

-		return MANHACK_MAX_SPEED * 0.1;

-	}

-

-	if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) )

-	{

-		return MANHACK_NPC_BURST_SPEED;

-	}

-

-	return MANHACK_MAX_SPEED;

-}

-

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Output :

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::ClampMotorForces( Vector &linear, AngularImpulse &angular )

-{

-	float scale = m_flBladeSpeed / 100.0;

-

-	// Msg("%.0f %.0f %.0f\n", linear.x, linear.y, linear.z );

-

-	float fscale = 3000 * scale;

-

-	if ( m_flEngineStallTime > gpGlobals->curtime )

-	{

-		linear.x = 0.0f;

-		linear.y = 0.0f;

-		linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale );

-	}

-	else

-	{

-		// limit reaction forces

-		linear.x = clamp( linear.x, -fscale, fscale );

-		linear.y = clamp( linear.y, -fscale, fscale );

-		linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale );

-	}

-

-	angular.x *= scale;

-	angular.y *= scale;

-	angular.z *= scale;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::KillSprites( float flDelay )

-{

-	if( m_pEyeGlow )

-	{

-		m_pEyeGlow->FadeAndDie( flDelay );

-		m_pEyeGlow = NULL;

-	}

-

-	if( m_pLightGlow )

-	{

-		m_pLightGlow->FadeAndDie( flDelay );

-		m_pLightGlow = NULL;

-	}

-

-	// Re-enable for light trails

-	/*

-	if ( m_hLightTrail )

-	{

-		m_hLightTrail->FadeAndDie( flDelay );

-		m_hLightTrail = NULL;

-	}

-	*/

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Tests whether we're above the target's feet but also below their top

-// Input  : *pTarget - who we're testing against

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::IsInEffectiveTargetZone( CBaseEntity *pTarget )

-{

-	Vector	vecMaxPos, vecMinPos;

-	float	ourHeight = WorldSpaceCenter().z;

-

-	// If the enemy is in a vehicle, we need to get those bounds

-	if ( pTarget && pTarget->IsPlayer() && assert_cast< CBasePlayer * >(pTarget)->IsInAVehicle() )

-	{

-		CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pTarget)->GetVehicleEntity();

-		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos );

-		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos );

-	

-		if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z )

-			return true;

-

-		return false;

-	}

-	

-	// Get the enemies top and bottom point

-	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos );

-#ifdef _XBOX

-	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.5f), &vecMinPos ); // Only half the body is valid

-#else

-	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos );

-#endif // _XBOX

-	// See if we're within that range

-	if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z )

-		return true;

-

-	return false;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : *pEnemy - 

-//			&chasePosition - 

-//			&tolerance - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition )

-{

-	if ( pEnemy && pEnemy->IsPlayer() && assert_cast< CBasePlayer * >(pEnemy)->IsInAVehicle() )

-	{

-		Vector vecNewPos;

-		CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pEnemy)->GetVehicleEntity();

-		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.5,0.5,0.5f), &vecNewPos );

-		chasePosition.z = vecNewPos.z;

-	}

-	else

-	{

-		Vector vecTarget;

-		pEnemy->CollisionProp()->NormalizedToCollisionSpace( Vector(0,0,0.75f), &vecTarget );

-		chasePosition.z += vecTarget.z;

-	}

-}

-

-float CNPC_Manhack::GetDefaultNavGoalTolerance()

-{

-	return GetHullWidth();

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: Input that disables the manhack's swarm behavior

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::InputDisableSwarm( inputdata_t &inputdata )

-{

-	m_bDoSwarmBehavior = false;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : &inputdata - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::InputUnpack( inputdata_t &inputdata )

-{

-	if ( HasSpawnFlags( SF_MANHACK_PACKED_UP ) == false )

-		return;

-

-	SetCondition( COND_LIGHT_DAMAGE );

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : *pPhysGunUser - 

-//			reason - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )

-{

-	m_hPhysicsAttacker = pPhysGunUser;

-	m_flLastPhysicsInfluenceTime = gpGlobals->curtime;

-

-	if ( reason == PUNTED_BY_CANNON )

-	{

-		StopLoitering();

-

-		m_bHeld = false;

-

-		// There's about to be a massive change in velocity. 

-		// Think immediately so we can do our slice traces, etc.

-		SetNextThink( gpGlobals->curtime + 0.01f );

-

-		// Stall our engine for awhile

-		m_flEngineStallTime = gpGlobals->curtime + 2.0f;

-		SetEyeState( MANHACK_EYE_STATE_STUNNED );

-	}

-	else

-	{

-		// Suppress collisions between the manhack and the player; we're currently bumping

-		// almost certainly because it's not purely a physics object.

-		SetOwnerEntity( pPhysGunUser );

-		m_bHeld = true;

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : *pPhysGunUser - 

-//			Reason - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )

-{

-	// Stop suppressing collisions between the manhack and the player

-	SetOwnerEntity( NULL );

-

-	m_bHeld = false;

-

-	if ( Reason == LAUNCHED_BY_CANNON )

-	{

-		m_hPhysicsAttacker = pPhysGunUser;

-		m_flLastPhysicsInfluenceTime = gpGlobals->curtime;

-

-		// There's about to be a massive change in velocity. 

-		// Think immediately so we can do our slice traces, etc.

-		SetNextThink( gpGlobals->curtime + 0.01f );

-

-		// Stall our engine for awhile

-		m_flEngineStallTime = gpGlobals->curtime + 2.0f;

-		SetEyeState( MANHACK_EYE_STATE_STUNNED );

-	}

-	else

-	{

-		if( m_bHackedByAlyx && !GetEnemy() )

-		{

-			// If a hacked manhack is released in peaceable conditions, 

-			// just loiter, don't zip off.

-			StartLoitering( GetAbsOrigin() );

-		}

-

-		m_hPhysicsAttacker = NULL;

-		m_flLastPhysicsInfluenceTime = 0;

-	}

-}

-

-void CNPC_Manhack::StartLoitering( const Vector &vecLoiterPosition )

-{

-	//Msg("Start Loitering\n");

-

-	m_vTargetBanking = vec3_origin;

-	m_vecLoiterPosition = GetAbsOrigin();

-	m_vForceVelocity = vec3_origin;

-	SetCurrentVelocity( vec3_origin );

-}

-

-CBasePlayer *CNPC_Manhack::HasPhysicsAttacker( float dt )

-{

-	// If the player is holding me now, or I've been recently thrown

-	// then return a pointer to that player

-	if ( IsHeldByPhyscannon() || (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime) )

-	{

-		return m_hPhysicsAttacker;

-	}

-	return NULL;

-}

-

-//-----------------------------------------------------------------------------

-// Manhacks that have been hacked by Alyx get more engine power (fly faster)

-//-----------------------------------------------------------------------------

-float CNPC_Manhack::GetMaxEnginePower()

-{

-	if( m_bHackedByAlyx )

-	{

-		return 2.0f;

-	}

-

-	return 1.0f;

-}

-

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::UpdatePanels( void )

-{

-	if ( m_flEngineStallTime > gpGlobals->curtime )

-	{

-		SetPoseParameter( m_iPanel1, random->RandomFloat( 0.0f, 90.0f ) );

-		SetPoseParameter( m_iPanel2, random->RandomFloat( 0.0f, 90.0f ) );

-		SetPoseParameter( m_iPanel3, random->RandomFloat( 0.0f, 90.0f ) );

-		SetPoseParameter( m_iPanel4, random->RandomFloat( 0.0f, 90.0f ) );

-		return;

-	}

-

-	float panelPosition = GetPoseParameter( m_iPanel1 );

-

-	if ( m_bShowingHostile )

-	{

-		panelPosition = 90.0f;//UTIL_Approach( 90.0f, panelPosition, 90.0f );

-	}

-	else

-	{

-		panelPosition = UTIL_Approach( 0.0f, panelPosition, 25.0f );

-	}

-

-	//FIXME: If we're going to have all these be equal, there's no need for 4 poses..

-	SetPoseParameter( m_iPanel1, panelPosition );

-	SetPoseParameter( m_iPanel2, panelPosition );

-	SetPoseParameter( m_iPanel3, panelPosition );

-	SetPoseParameter( m_iPanel4, panelPosition );

-

-	//TODO: Make these waver randomly?

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Input  : hostile - 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::ShowHostile( bool hostile /*= true*/)

-{

-	if ( m_bShowingHostile == hostile )

-		return;

-

-	//TODO: Open the manhack panels or close them, depending on the state

-	m_bShowingHostile = hostile;

-

-	if ( hostile )

-	{

-		EmitSound( "NPC_Manhack.ChargeAnnounce" );

-	}

-	else

-	{

-		EmitSound( "NPC_Manhack.ChargeEnd" );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StartBurst( const Vector &vecDirection )

-{

-	if ( m_flBurstDuration > gpGlobals->curtime )

-		return;

-

-	ShowHostile();

-

-	// Don't burst attack again for a couple seconds

-	m_flNextBurstTime = gpGlobals->curtime + 2.0;

-	m_flBurstDuration = gpGlobals->curtime + 1.0;

-	

-	// Save off where we were going towards and for how long

-	m_vecBurstDirection = vecDirection;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::StopBurst( bool bInterruptSchedule /*= false*/ )

-{

-	if ( m_flBurstDuration < gpGlobals->curtime )

-		return;

-

-	ShowHostile( false );

-

-	// Stop our burst timers

-	m_flNextBurstTime = gpGlobals->curtime + 2.0f; //FIXME: Skill level based

-	m_flBurstDuration = gpGlobals->curtime - 0.1f;

-

-	if ( bInterruptSchedule )

-	{

-		// We need to rethink our current schedule

-		ClearSchedule( "Stopping burst" );

-	}

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-//-----------------------------------------------------------------------------

-void CNPC_Manhack::SetEyeState( int state )

-{

-	// Make sure we're active

-	StartEye();

-

-	switch( state )

-	{

-	case MANHACK_EYE_STATE_STUNNED:

-		{

-			if ( m_pEyeGlow )

-			{

-				//Toggle our state

-				m_pEyeGlow->SetColor( 255, 128, 0 );

-				m_pEyeGlow->SetScale( 0.15f, 0.1f );

-				m_pEyeGlow->SetBrightness( 164, 0.1f );

-				m_pEyeGlow->m_nRenderFX = kRenderFxStrobeFast;

-			}

-			

-			if ( m_pLightGlow )

-			{

-				m_pLightGlow->SetColor( 255, 128, 0 );

-				m_pLightGlow->SetScale( 0.15f, 0.1f );

-				m_pLightGlow->SetBrightness( 164, 0.1f );

-				m_pLightGlow->m_nRenderFX = kRenderFxStrobeFast;

-			}

-

-			EmitSound("NPC_Manhack.Stunned");

-

-			break;

-		}

-

-	case MANHACK_EYE_STATE_CHARGE:

-		{

-			if ( m_pEyeGlow )

-			{

-				//Toggle our state

-				if( m_bHackedByAlyx )

-				{

-					m_pEyeGlow->SetColor( 0, 255, 0 );

-				}

-				else

-				{

-					m_pEyeGlow->SetColor( 255, 0, 0 );

-				}

-

-				m_pEyeGlow->SetScale( 0.25f, 0.5f );

-				m_pEyeGlow->SetBrightness( 164, 0.1f );

-				m_pEyeGlow->m_nRenderFX = kRenderFxNone;

-			}

-			

-			if ( m_pLightGlow )

-			{

-				if( m_bHackedByAlyx )

-				{

-					m_pLightGlow->SetColor( 0, 255, 0 );

-				}

-				else

-				{

-					m_pLightGlow->SetColor( 255, 0, 0 );

-				}

-

-				m_pLightGlow->SetScale( 0.25f, 0.5f );

-				m_pLightGlow->SetBrightness( 164, 0.1f );

-				m_pLightGlow->m_nRenderFX = kRenderFxNone;

-			}

-

-			break;

-		}

-	

-	default:

-		if ( m_pEyeGlow )

-			m_pEyeGlow->m_nRenderFX = kRenderFxNone;

-		break;

-	}

-}

-

-

-unsigned int CNPC_Manhack::PhysicsSolidMaskForEntity( void ) const 

-{ 

-	unsigned int mask = BaseClass::PhysicsSolidMaskForEntity();

-	if ( m_bIgnoreClipbrushes )

-	{

-		mask &= ~CONTENTS_MONSTERCLIP;

-	}

-	return mask;

-}

-

-//-----------------------------------------------------------------------------

-// Purpose: 

-// Output : Returns true on success, false on failure.

-//-----------------------------------------------------------------------------

-bool CNPC_Manhack::CreateVPhysics( void )

-{

-	if ( HasSpawnFlags( SF_MANHACK_CARRIED ) )

-		return false;

-

-	return BaseClass::CreateVPhysics();

-}

-

-//-----------------------------------------------------------------------------

-//

-// Schedules

-//

-//-----------------------------------------------------------------------------

-AI_BEGIN_CUSTOM_NPC( npc_manhack, CNPC_Manhack )

-

-	DECLARE_TASK( TASK_MANHACK_HOVER );

-	DECLARE_TASK( TASK_MANHACK_UNPACK );

-	DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_CENTER );

-	DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_MEMBER );

-	DECLARE_TASK( TASK_MANHACK_MOVEAT_SAVEPOSITION );

-

-	DECLARE_CONDITION( COND_MANHACK_START_ATTACK );

-

-	DECLARE_ACTIVITY( ACT_MANHACK_UNPACK );

-

-//=========================================================

-// > SCHED_MANHACK_ATTACK_HOVER

-//=========================================================

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_ATTACK_HOVER,

-

-	"	Tasks"

-	"		TASK_SET_ACTIVITY		ACTIVITY:ACT_FLY"

-	"		TASK_MANHACK_HOVER		0"

-	"	"

-	"	Interrupts"

-	"		COND_TOO_FAR_TO_ATTACK"

-	"		COND_TOO_CLOSE_TO_ATTACK"

-	"		COND_NEW_ENEMY"

-	"		COND_ENEMY_DEAD"

-	"		COND_LIGHT_DAMAGE"

-	"		COND_HEAVY_DAMAGE"

-	"		COND_ENEMY_OCCLUDED"

-);

-

-

-//=========================================================

-// > SCHED_MANHACK_ATTACK_HOVER

-//=========================================================

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_DEPLOY,

-

-	"	Tasks"

-	"		TASK_PLAY_SEQUENCE			ACTIVITY:ACT_MANHACK_UNPACK"

-	"		TASK_SET_ACTIVITY			ACTIVITY:ACT_FLY"

-	"	"

-//	"	Interrupts"

-);

-

-//=========================================================

-// > SCHED_MANHACK_REGROUP

-//=========================================================

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_REGROUP,

-

-	"	Tasks"

-	"		TASK_STOP_MOVING							0"

-	"		TASK_SET_TOLERANCE_DISTANCE					24"

-	"		TASK_STORE_ENEMY_POSITION_IN_SAVEPOSITION	0"

-	"		TASK_FIND_BACKAWAY_FROM_SAVEPOSITION		0"

-	"		TASK_RUN_PATH								0"

-	"		TASK_WAIT_FOR_MOVEMENT						0"

-	"	"

-	"	Interrupts"

-	"		COND_MANHACK_START_ATTACK"

-	"		COND_NEW_ENEMY"

-	"		COND_CAN_MELEE_ATTACK1"

-);

-

-

-

-//=========================================================

-// > SCHED_MANHACK_SWARN

-//=========================================================

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_SWARM_IDLE,

-

-	"	Tasks"

-	"		TASK_STOP_MOVING							0"

-	"		TASK_SET_FAIL_SCHEDULE						SCHEDULE:SCHED_MANHACK_SWARM_FAILURE"

-	"		TASK_MANHACK_FIND_SQUAD_CENTER				0"

-	"		TASK_MANHACK_MOVEAT_SAVEPOSITION			5"

-	"	"

-	"	Interrupts"

-	"		COND_NEW_ENEMY"

-	"		COND_SEE_ENEMY"

-	"		COND_SEE_FEAR"

-	"		COND_LIGHT_DAMAGE"

-	"		COND_HEAVY_DAMAGE"

-	"		COND_SMELL"

-	"		COND_PROVOKED"

-	"		COND_GIVE_WAY"

-	"		COND_HEAR_PLAYER"

-	"		COND_HEAR_DANGER"

-	"		COND_HEAR_COMBAT"

-	"		COND_HEAR_BULLET_IMPACT"

-);

-

-

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_SWARM,

-

-	"	Tasks"

-	"		TASK_STOP_MOVING							0"

-	"		TASK_SET_FAIL_SCHEDULE						SCHEDULE:SCHED_MANHACK_SWARM_FAILURE"

-	"		TASK_MANHACK_FIND_SQUAD_CENTER				0"

-	"		TASK_MANHACK_MOVEAT_SAVEPOSITION			1"

-	"	"

-	"	Interrupts"

-	"		COND_NEW_ENEMY"

-	"		COND_CAN_MELEE_ATTACK1"

-	"		COND_LIGHT_DAMAGE"

-	"		COND_HEAVY_DAMAGE"

-);

-

-DEFINE_SCHEDULE

-(

-	SCHED_MANHACK_SWARM_FAILURE,

-

-	"	Tasks"

-	"		TASK_STOP_MOVING							0"

-	"		TASK_WAIT									2"

-	"		TASK_WAIT_RANDOM							2"

-	"		TASK_MANHACK_FIND_SQUAD_MEMBER				0"

-	"		TASK_GET_PATH_TO_SAVEPOSITION				0"

-	"		TASK_WAIT_FOR_MOVEMENT						0"

-	"	"

-	"	Interrupts"

-	"		COND_SEE_ENEMY"

-	"		COND_NEW_ENEMY"

-);

-

-AI_END_CUSTOM_NPC()

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "soundenvelope.h"
+#include "npc_manhack.h"
+#include "ai_default.h"
+#include "ai_node.h"
+#include "ai_navigator.h"
+#include "ai_pathfinder.h"
+#include "ai_moveprobe.h"
+#include "ai_memory.h"
+#include "ai_squad.h"
+#include "ai_route.h"
+#include "explode.h"
+#include "basegrenade_shared.h"
+#include "ndebugoverlay.h"
+#include "decals.h"
+#include "gib.h"
+#include "game.h"			
+#include "ai_interactions.h"
+#include "IEffects.h"
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+#include "movevars_shared.h"
+#include "npcevent.h"
+#include "props.h"
+#include "te_effect_dispatch.h"
+#include "ai_squadslot.h"
+#include "world.h"
+#include "smoke_trail.h"
+#include "func_break.h"
+#include "physics_impact_damage.h"
+#include "weapon_physcannon.h"
+#include "physics_prop_ragdoll.h"
+#include "soundent.h"
+#include "ammodef.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// When the engine is running and the manhack is operating under power
+// we don't let gravity affect him.
+#define MANHACK_GRAVITY 0.000
+
+#define MANHACK_GIB_COUNT			5 
+#define MANHACK_INGORE_WATER_DIST	384
+
+// Sound stuff
+#define MANHACK_PITCH_DIST1		512
+#define MANHACK_MIN_PITCH1		(100)
+#define MANHACK_MAX_PITCH1		(160)
+#define MANHACK_WATER_PITCH1	(85)
+#define MANHACK_VOLUME1			0.55
+
+#define MANHACK_PITCH_DIST2		400
+#define MANHACK_MIN_PITCH2		(85)
+#define MANHACK_MAX_PITCH2		(190)
+#define MANHACK_WATER_PITCH2	(90)
+
+#define MANHACK_NOISEMOD_HIDE 5000
+
+#define MANHACK_BODYGROUP_BLADE	1
+#define MANHACK_BODYGROUP_BLUR	2
+#define MANHACK_BODYGROUP_OFF	0
+#define MANHACK_BODYGROUP_ON	1
+
+// ANIMATION EVENTS
+#define MANHACK_AE_START_ENGINE			50
+#define MANHACK_AE_DONE_UNPACKING		51
+#define MANHACK_AE_OPEN_BLADE			52
+
+//#define MANHACK_GLOW_SPRITE	"sprites/laserdot.vmt"
+#define MANHACK_GLOW_SPRITE	"sprites/glow1.vmt"
+
+#define	MANHACK_CHARGE_MIN_DIST	200
+
+ConVar	sk_manhack_health( "sk_manhack_health","0");
+ConVar	sk_manhack_melee_dmg( "sk_manhack_melee_dmg","0");
+ConVar	sk_manhack_v2( "sk_manhack_v2","1");
+
+extern void		SpawnBlood(Vector vecSpot, const Vector &vAttackDir, int bloodColor, float flDamage);
+extern float	GetFloorZ(const Vector &origin);
+
+//-----------------------------------------------------------------------------
+// Private activities.
+//-----------------------------------------------------------------------------
+Activity ACT_MANHACK_UNPACK;
+
+//-----------------------------------------------------------------------------
+// Manhack Conditions
+//-----------------------------------------------------------------------------
+enum ManhackConditions
+{
+	COND_MANHACK_START_ATTACK = LAST_SHARED_CONDITION,	// We are able to do a bombing run on the current enemy.
+};
+
+//-----------------------------------------------------------------------------
+// Manhack schedules.
+//-----------------------------------------------------------------------------
+enum ManhackSchedules
+{
+	SCHED_MANHACK_ATTACK_HOVER = LAST_SHARED_SCHEDULE,
+	SCHED_MANHACK_DEPLOY,
+	SCHED_MANHACK_REGROUP,
+	SCHED_MANHACK_SWARM_IDLE,
+	SCHED_MANHACK_SWARM,
+	SCHED_MANHACK_SWARM_FAILURE,
+};
+
+
+//-----------------------------------------------------------------------------
+// Manhack tasks.
+//-----------------------------------------------------------------------------
+enum ManhackTasks
+{
+	TASK_MANHACK_HOVER = LAST_SHARED_TASK,
+	TASK_MANHACK_UNPACK,
+	TASK_MANHACK_FIND_SQUAD_CENTER,
+	TASK_MANHACK_FIND_SQUAD_MEMBER,
+	TASK_MANHACK_MOVEAT_SAVEPOSITION,
+};
+
+BEGIN_DATADESC( CNPC_Manhack )
+
+	DEFINE_FIELD( m_vForceVelocity,			FIELD_VECTOR),
+
+	DEFINE_FIELD( m_vTargetBanking,			FIELD_VECTOR),
+	DEFINE_FIELD( m_vForceMoveTarget,			FIELD_POSITION_VECTOR),
+	DEFINE_FIELD( m_fForceMoveTime,			FIELD_TIME),
+	DEFINE_FIELD( m_vSwarmMoveTarget,			FIELD_POSITION_VECTOR),
+	DEFINE_FIELD( m_fSwarmMoveTime,			FIELD_TIME),
+	DEFINE_FIELD( m_fEnginePowerScale,		FIELD_FLOAT),
+
+	DEFINE_FIELD( m_flNextEngineSoundTime,	FIELD_TIME),
+	DEFINE_FIELD( m_flEngineStallTime,		FIELD_TIME),
+	DEFINE_FIELD( m_flNextBurstTime,			FIELD_TIME ),
+	DEFINE_FIELD( m_flWaterSuspendTime,		FIELD_TIME),
+	DEFINE_FIELD( m_nLastSpinSound,			FIELD_INTEGER ),
+
+	// Death
+	DEFINE_FIELD( m_fSparkTime,				FIELD_TIME),
+	DEFINE_FIELD( m_fSmokeTime,				FIELD_TIME),
+
+	DEFINE_FIELD( m_bDirtyPitch,			FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bGib,					FIELD_BOOLEAN),
+	DEFINE_FIELD( m_bHeld,					FIELD_BOOLEAN),
+	
+	DEFINE_FIELD( m_bHackedByAlyx,			FIELD_BOOLEAN),
+	DEFINE_FIELD( m_vecLoiterPosition,		FIELD_POSITION_VECTOR),
+	DEFINE_FIELD( m_fTimeNextLoiterPulse,	FIELD_TIME),
+
+	DEFINE_FIELD( m_flBumpSuppressTime,		FIELD_TIME ),
+
+	DEFINE_FIELD( m_bBladesActive,			FIELD_BOOLEAN),
+	DEFINE_FIELD( m_flBladeSpeed,				FIELD_FLOAT),
+	DEFINE_KEYFIELD( m_bIgnoreClipbrushes,	FIELD_BOOLEAN, "ignoreclipbrushes" ),
+	DEFINE_FIELD( m_hSmokeTrail,				FIELD_EHANDLE),
+
+	// DEFINE_FIELD( m_pLightGlow,				FIELD_CLASSPTR ),
+	// DEFINE_FIELD( m_pEyeGlow,					FIELD_CLASSPTR ),
+
+	DEFINE_FIELD( m_iPanel1, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iPanel2, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iPanel3, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iPanel4, FIELD_INTEGER ),
+
+	DEFINE_FIELD( m_nLastWaterLevel,			FIELD_INTEGER ),
+	DEFINE_FIELD( m_bDoSwarmBehavior,			FIELD_BOOLEAN ),
+
+	DEFINE_FIELD( m_nEnginePitch1,				FIELD_INTEGER ),
+	DEFINE_FIELD( m_flEnginePitch1Time,			FIELD_TIME ),
+	DEFINE_FIELD( m_nEnginePitch2,				FIELD_INTEGER ),
+	DEFINE_FIELD( m_flEnginePitch2Time,			FIELD_TIME ),
+
+	// Physics Influence
+	DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ),
+
+	DEFINE_FIELD( m_flBurstDuration,	FIELD_FLOAT ),
+	DEFINE_FIELD( m_vecBurstDirection,	FIELD_VECTOR ),
+	DEFINE_FIELD( m_bShowingHostile,	FIELD_BOOLEAN ),
+
+	// Function Pointers
+	DEFINE_INPUTFUNC( FIELD_VOID,	"DisableSwarm", InputDisableSwarm ),
+	DEFINE_INPUTFUNC( FIELD_VOID,   "Unpack",		InputUnpack ),
+
+	DEFINE_ENTITYFUNC( CrashTouch ),
+
+	DEFINE_BASENPCINTERACTABLE_DATADESC(),
+
+END_DATADESC()
+
+
+LINK_ENTITY_TO_CLASS( npc_manhack, CNPC_Manhack );
+
+IMPLEMENT_SERVERCLASS_ST(CNPC_Manhack, DT_NPC_Manhack)
+	SendPropIntWithMinusOneFlag	(SENDINFO(m_nEnginePitch1), 8 ),
+	SendPropFloat(SENDINFO(m_flEnginePitch1Time), 0, SPROP_NOSCALE),
+	SendPropIntWithMinusOneFlag(SENDINFO(m_nEnginePitch2), 8 )
+END_SEND_TABLE()
+
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+CNPC_Manhack::CNPC_Manhack()
+{
+#ifdef _DEBUG
+	m_vForceMoveTarget.Init();
+	m_vSwarmMoveTarget.Init();
+	m_vTargetBanking.Init();
+	m_vForceVelocity.Init();
+#endif
+	m_bDirtyPitch = true;
+	m_nLastWaterLevel = 0;
+	m_nEnginePitch1 = -1;
+	m_nEnginePitch2 = -1;
+	m_flEnginePitch1Time = 0;
+	m_flEnginePitch1Time = 0;
+	m_bDoSwarmBehavior = true;
+	m_flBumpSuppressTime = 0;
+}
+
+//------------------------------------------------------------------------------
+// Purpose:
+//------------------------------------------------------------------------------
+CNPC_Manhack::~CNPC_Manhack()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Indicates this NPC's place in the relationship table.
+//-----------------------------------------------------------------------------
+Class_T	CNPC_Manhack::Classify(void)
+{
+	return (m_bHeld||m_bHackedByAlyx) ? CLASS_PLAYER_ALLY : CLASS_MANHACK; 
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Turns the manhack into a physics corpse when dying.
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Event_Dying(void)
+{
+	DestroySmokeTrail();
+	SetHullSizeNormal();
+	BaseClass::Event_Dying();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::GatherConditions()
+{
+	BaseClass::GatherConditions();
+
+	if( IsLoitering() && GetEnemy() )
+	{
+		StopLoitering();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::PrescheduleThink( void )
+{
+	BaseClass::PrescheduleThink();
+
+	UpdatePanels();
+
+	if( m_flWaterSuspendTime > gpGlobals->curtime )
+	{
+		// Stuck in water!
+
+		// Reduce engine power so that the manhack lifts out of the water slowly.
+		m_fEnginePowerScale = 0.75;
+	}
+
+	// ----------------------------------------
+	//	Am I in water?
+	// ----------------------------------------
+	if ( GetWaterLevel() > 0 )
+	{
+		if( m_nLastWaterLevel == 0 )
+		{
+			Splash( WorldSpaceCenter() );
+		}
+
+		if( IsAlive() )
+		{
+			// If I've been out of water for 2 seconds or more, I'm eligible to be stuck in water again.
+			if( gpGlobals->curtime - m_flWaterSuspendTime > 2.0 )
+			{
+				m_flWaterSuspendTime = gpGlobals->curtime + 1.0;
+			}
+		}
+	}
+	else
+	{
+		if( m_nLastWaterLevel != 0 )
+		{
+			Splash( WorldSpaceCenter() );
+		}
+	}
+
+	m_nLastWaterLevel = GetWaterLevel();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	g_vecAttackDir = vecDir;
+
+	if ( info.GetDamageType() & DMG_BULLET)
+	{
+		g_pEffects->Ricochet(ptr->endpos,ptr->plane.normal);
+	}
+
+	if ( info.GetDamageType() & DMG_CLUB )
+	{
+		// Clubbed!
+//		UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10);
+		g_pEffects->Sparks( ptr->endpos, 1, 1, &ptr->plane.normal );
+	}
+
+	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::DeathSound( const CTakeDamageInfo &info )
+{
+	StopSound("NPC_Manhack.Stunned");
+	CPASAttenuationFilter filter2( this, "NPC_Manhack.Die" );
+	EmitSound( filter2, entindex(), "NPC_Manhack.Die" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::ShouldGib( const CTakeDamageInfo &info )
+{
+	return ( m_bGib );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Event_Killed( const CTakeDamageInfo &info )
+{
+	// turn off the blur!
+	SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );
+
+	// Sparks
+	for (int i = 0; i < 3; i++)
+	{
+		Vector sparkPos = GetAbsOrigin();
+		sparkPos.x += random->RandomFloat(-12,12);
+		sparkPos.y += random->RandomFloat(-12,12);
+		sparkPos.z += random->RandomFloat(-12,12);
+		g_pEffects->Sparks( sparkPos, 2 );
+	}
+
+	// Light
+	CBroadcastRecipientFilter filter;
+	te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 100, 0.1, 0 );
+
+	if ( m_nEnginePitch1 < 0 )
+	{
+		// Probably this manhack was killed immediately after spawning. Turn the sound
+		// on right now so that we can pitch it up for the crash!
+		SoundInit();
+	}
+
+	// Always gib when clubbed or blasted or crushed, or just randomly
+	if ( ( info.GetDamageType() & (DMG_CLUB|DMG_CRUSH|DMG_BLAST) ) || ( random->RandomInt( 0, 1 ) ) )
+	{
+		m_bGib = true;
+	}
+	else
+	{
+		m_bGib = false;
+		
+		//FIXME: These don't stay with the ragdolls currently -- jdw
+		// Long fadeout on the sprites!!
+		KillSprites( 0.0f );
+	}
+
+	BaseClass::Event_Killed( info );
+}
+
+void CNPC_Manhack::HitPhysicsObject( CBaseEntity *pOther )
+{
+	IPhysicsObject *pOtherPhysics = pOther->VPhysicsGetObject();
+	Vector pos, posOther;
+	// Put the force on the line between the manhack origin and hit object origin
+	VPhysicsGetObject()->GetPosition( &pos, NULL );
+	pOtherPhysics->GetPosition( &posOther, NULL );
+	Vector dir = posOther - pos;
+	VectorNormalize(dir);
+	// size/2 is approx radius
+	pos += dir * WorldAlignSize().x * 0.5;
+	Vector cross;
+
+	// UNDONE: Use actual manhack up vector so the fake blade is
+	// in the right plane?
+	// Get a vector in the x/y plane in the direction of blade spin (clockwise)
+	CrossProduct( dir, Vector(0,0,1), cross );
+	VectorNormalize( cross );
+	// force is a 30kg object going 100 in/s
+	pOtherPhysics->ApplyForceOffset( cross * 30 * 100, pos );
+}
+
+
+//-----------------------------------------------------------------------------
+// Take damage from being thrown by a physcannon 
+//-----------------------------------------------------------------------------
+#define MANHACK_SMASH_SPEED 500.0	// How fast a manhack must slam into something to take full damage
+void CNPC_Manhack::TakeDamageFromPhyscannon( CBasePlayer *pPlayer )
+{
+	CTakeDamageInfo info;
+	info.SetDamageType( DMG_GENERIC );
+	info.SetInflictor( this );
+	info.SetAttacker( pPlayer );
+	info.SetDamagePosition( GetAbsOrigin() );
+	info.SetDamageForce( Vector( 1.0, 1.0, 1.0 ) );
+
+	// Convert velocity into damage.
+	Vector vel;
+	VPhysicsGetObject()->GetVelocity( &vel, NULL );
+	float flSpeed = vel.Length();
+
+	float flFactor = flSpeed / MANHACK_SMASH_SPEED;
+
+	// Clamp. Don't inflict negative damage or massive damage!
+	flFactor = clamp( flFactor, 0.0f, 2.0f );
+	float flDamage = m_iMaxHealth * flFactor;
+
+#if 0
+	Msg("Doing %f damage for %f speed!\n", flDamage, flSpeed );
+#endif
+
+	info.SetDamage( flDamage );
+	TakeDamage( info );
+}
+
+
+//-----------------------------------------------------------------------------
+// Take damage from a vehicle; it's like a really big crowbar 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::TakeDamageFromVehicle( int index, gamevcollisionevent_t *pEvent )
+{
+	// Use the vehicle velocity to determine the damage
+	int otherIndex = !index;
+	CBaseEntity *pOther = pEvent->pEntities[otherIndex];
+
+	float flSpeed = pEvent->preVelocity[ otherIndex ].Length();
+	flSpeed = clamp( flSpeed, 300.0f, 600.0f );
+	float flDamage = SimpleSplineRemapVal( flSpeed, 300.0f, 600.0f, 0.0f, 1.0f );
+	if ( flDamage == 0.0f )
+		return;
+
+	flDamage *= 20.0f;
+
+	Vector damagePos;
+	pEvent->pInternalData->GetContactPoint( damagePos );
+
+	Vector damageForce = 2.0f * pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
+	if ( damageForce == vec3_origin )
+	{
+		// This can happen if this entity is a func_breakable, and can't move.
+		// Use the velocity of the entity that hit us instead.
+		damageForce = 2.0f * pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();
+	}
+	Assert( damageForce != vec3_origin );
+	CTakeDamageInfo dmgInfo( pOther, pOther, damageForce, damagePos, flDamage, DMG_CRUSH );
+	TakeDamage( dmgInfo );
+}
+
+
+//-----------------------------------------------------------------------------
+// Take damage from combine ball
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::TakeDamageFromPhysicsImpact( int index, gamevcollisionevent_t *pEvent )
+{
+	CBaseEntity *pHitEntity = pEvent->pEntities[!index];
+
+	// NOTE: Bypass the normal impact energy scale here.
+	float flDamageScale = PlayerHasMegaPhysCannon() ? 10.0f : 1.0f;
+	int damageType = 0;
+	float damage = CalculateDefaultPhysicsDamage( index, pEvent, flDamageScale, true, damageType );
+	if ( damage == 0 )
+		return;
+
+	Vector damagePos;
+	pEvent->pInternalData->GetContactPoint( damagePos );
+	Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();
+	if ( damageForce == vec3_origin )
+	{
+		// This can happen if this entity is motion disabled, and can't move.
+		// Use the velocity of the entity that hit us instead.
+		damageForce = pEvent->postVelocity[!index] * pEvent->pObjects[!index]->GetMass();
+	}
+
+	// FIXME: this doesn't pass in who is responsible if some other entity "caused" this collision
+	PhysCallbackDamage( this, CTakeDamageInfo( pHitEntity, pHitEntity, damageForce, damagePos, damage, damageType ), *pEvent, index );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+#define MANHACK_SMASH_TIME	0.35		// How long after being thrown from a physcannon that a manhack is eligible to die from impact
+void CNPC_Manhack::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
+{
+	BaseClass::VPhysicsCollision( index, pEvent );
+
+	// Take no impact damage while being carried.
+	if ( IsHeldByPhyscannon() )
+		return;
+
+	// Wake us up
+	if ( m_spawnflags & SF_MANHACK_PACKED_UP )
+	{
+		SetCondition( COND_LIGHT_DAMAGE );
+	}
+
+	int otherIndex = !index;
+	CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];
+
+	CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME );
+	if( pPlayer )
+	{
+		if (!pHitEntity)
+		{
+			TakeDamageFromPhyscannon( pPlayer );
+			StopBurst( true );
+			return;
+		}
+
+		// Don't take damage from NPCs or server ragdolls killed by the manhack
+		CRagdollProp *pRagdollProp = dynamic_cast<CRagdollProp*>(pHitEntity);
+		if (!pHitEntity->IsNPC() && (!pRagdollProp || pRagdollProp->GetKiller() != this))
+		{
+			TakeDamageFromPhyscannon( pPlayer );
+			StopBurst( true );
+			return;
+		}
+	}
+
+	if ( pHitEntity )
+	{
+		// It can take physics damage if it rams into a vehicle
+		if ( pHitEntity->GetServerVehicle() )
+		{
+			TakeDamageFromVehicle( index, pEvent );
+		}
+		else if ( pHitEntity->HasPhysicsAttacker( 0.5f ) )
+		{
+			// It also can take physics damage from things thrown by the player.
+			TakeDamageFromPhysicsImpact( index, pEvent );
+		}
+		else if ( FClassnameIs( pHitEntity, "prop_combine_ball" ) )
+		{
+			// It also can take physics damage from a combine ball.
+			TakeDamageFromPhysicsImpact( index, pEvent );
+		}
+		else if ( m_iHealth <= 0 )
+		{
+			TakeDamageFromPhysicsImpact( index, pEvent );
+		}
+
+		StopBurst( true );
+	}
+}
+
+
+void CNPC_Manhack::VPhysicsShadowCollision( int index, gamevcollisionevent_t *pEvent )
+{
+	int otherIndex = !index;
+	CBaseEntity *pOther = pEvent->pEntities[otherIndex];
+
+	if ( pOther->GetMoveType() == MOVETYPE_VPHYSICS )
+	{
+		HitPhysicsObject( pOther );
+	}
+	BaseClass::VPhysicsShadowCollision( index, pEvent );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Manhack is out of control! (dying) Just explode as soon as you touch anything!
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::CrashTouch( CBaseEntity *pOther )
+{
+	CTakeDamageInfo	info( GetWorldEntity(), GetWorldEntity(), 25, DMG_CRUSH );
+
+	CorpseGib( info );
+}
+
+
+//-----------------------------------------------------------------------------
+// Create smoke trail!
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::CreateSmokeTrail()
+{
+	if ( HasSpawnFlags( SF_MANHACK_NO_DAMAGE_EFFECTS ) )
+		return;
+
+	if ( m_hSmokeTrail != NULL )
+		return;
+
+	SmokeTrail *pSmokeTrail =  SmokeTrail::CreateSmokeTrail();
+	if( !pSmokeTrail )
+		return;
+
+	pSmokeTrail->m_SpawnRate = 20;
+	pSmokeTrail->m_ParticleLifetime = 0.5f;
+	pSmokeTrail->m_StartSize	= 8;
+	pSmokeTrail->m_EndSize		= 32;
+	pSmokeTrail->m_SpawnRadius	= 5;
+	pSmokeTrail->m_MinSpeed		= 15;
+	pSmokeTrail->m_MaxSpeed		= 25;
+	
+	pSmokeTrail->m_StartColor.Init( 0.4f, 0.4f, 0.4f );
+	pSmokeTrail->m_EndColor.Init( 0, 0, 0 );
+	
+	pSmokeTrail->SetLifetime(-1);
+	pSmokeTrail->FollowEntity(this);
+
+	m_hSmokeTrail = pSmokeTrail;
+}
+
+void CNPC_Manhack::DestroySmokeTrail()
+{
+	if ( m_hSmokeTrail.Get() )
+	{
+		UTIL_Remove( m_hSmokeTrail );
+		m_hSmokeTrail = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+int	CNPC_Manhack::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	// Hafta make a copy of info cause we might need to scale damage.(sjb)
+	CTakeDamageInfo tdInfo = info;
+
+	if( tdInfo.GetAmmoType() == GetAmmoDef()->Index("SniperRound") )
+	{
+		// Unfortunately, this is the easiest way to stop the sniper killing manhacks in one shot.
+		tdInfo.SetDamage( m_iMaxHealth>>1 );
+	}
+
+	if (info.GetDamageType() & DMG_PHYSGUN )
+	{
+		m_flBladeSpeed = 20.0;
+
+		// respond to physics
+		// FIXME: shouldn't this happen in a base class?  Anyway to prevent it from happening twice?
+		VPhysicsTakeDamage( info );
+
+		// reduce damage to nothing
+		tdInfo.SetDamage( 1.0 );
+
+		StopBurst( true );
+	}
+	else if ( info.GetDamageType() & DMG_AIRBOAT )
+	{
+		// Airboat gun kills me instantly.
+		tdInfo.SetDamage( GetHealth() );
+	}
+	else if (info.GetDamageType() & DMG_CLUB)
+	{
+		// Being hit by a club means a couple of things:
+		//
+		//		-I'm going to be knocked away from the person that clubbed me.
+		//		 if fudging this vector a little bit could help me slam into a physics object,
+		//		 then make that adjustment. This is a simple heuristic. The manhack will be
+		//		 directed towards the physics object that is closest to g_vecAttackDir
+		//
+
+		//		-Take 150% damage from club attacks. This makes crowbar duels take two hits.
+		
+		tdInfo.ScaleDamage( 1.50 );
+
+#define MANHACK_PHYS_SEARCH_SIZE		64
+#define	MANHACK_PHYSICS_SEARCH_RADIUS	128
+
+		CBaseEntity *pList[ MANHACK_PHYS_SEARCH_SIZE ];
+
+		Vector attackDir = info.GetDamageForce();
+		VectorNormalize( attackDir );
+
+		Vector testCenter = GetAbsOrigin() + ( attackDir * MANHACK_PHYSICS_SEARCH_RADIUS );
+		Vector vecDelta( MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS, MANHACK_PHYSICS_SEARCH_RADIUS );
+
+		int count = UTIL_EntitiesInBox( pList, MANHACK_PHYS_SEARCH_SIZE, testCenter - vecDelta, testCenter + vecDelta, 0 );
+
+		Vector			vecBestDir = g_vecAttackDir;
+		float			flBestDot = 0.90;
+		IPhysicsObject	*pPhysObj;
+
+		int i;
+		for( i = 0 ; i < count ; i++ )
+		{
+			pPhysObj = pList[ i ]->VPhysicsGetObject();
+
+			if( !pPhysObj || pPhysObj->GetMass() > 200 )
+			{
+				// Not physics.
+				continue;
+			}
+
+			Vector center = pList[ i ]->WorldSpaceCenter();
+
+			Vector vecDirToObject;
+			VectorSubtract( center, WorldSpaceCenter(), vecDirToObject );
+			VectorNormalize( vecDirToObject );
+
+			float flDot;
+
+			flDot = DotProduct( g_vecAttackDir, vecDirToObject );
+			
+
+			if( flDot > flBestDot )
+			{
+				flBestDot = flDot;
+				vecBestDir = vecDirToObject;
+			}
+		}
+
+		tdInfo.SetDamageForce( vecBestDir * info.GetDamage() * 200 );
+
+		// FIXME: shouldn't this happen in a base class?  Anyway to prevent it from happening twice?
+		VPhysicsTakeDamage( tdInfo );
+
+		// Force us away (no more residual speed hits!)
+		m_vForceVelocity = vecBestDir * info.GetDamage() * 0.5f;
+		m_flBladeSpeed = 10.0;
+
+		EmitSound( "NPC_Manhack.Bat" );	
+
+		// tdInfo.SetDamage( 1.0 );
+
+		m_flEngineStallTime = gpGlobals->curtime + 0.5f;
+		StopBurst( true );
+	}
+	else
+	{
+		m_flBladeSpeed = 20.0;
+
+		Vector vecDamageDir = tdInfo.GetDamageForce();
+		VectorNormalize( vecDamageDir );
+
+		m_flEngineStallTime = gpGlobals->curtime + 0.25f;
+		m_vForceVelocity = vecDamageDir * info.GetDamage() * 20.0f;
+
+		tdInfo.SetDamageForce( tdInfo.GetDamageForce() * 20 );
+
+		VPhysicsTakeDamage( info );
+	}
+
+	int nRetVal = BaseClass::OnTakeDamage_Alive( tdInfo );
+	if ( nRetVal )
+	{
+		if ( m_iHealth > 0 )
+		{
+			if ( info.GetDamageType() & DMG_CLUB )
+			{
+				SetEyeState( MANHACK_EYE_STATE_STUNNED );
+			}
+
+			if ( m_iHealth <= ( m_iMaxHealth / 2 ) )
+			{
+				CreateSmokeTrail();
+			}
+		}
+		else
+		{
+			DestroySmokeTrail();
+		}
+	}
+
+	return nRetVal;
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose:
+//------------------------------------------------------------------------------
+bool CNPC_Manhack::CorpseGib( const CTakeDamageInfo &info )
+{
+	Vector			vecGibVelocity;
+	AngularImpulse	vecGibAVelocity;
+
+	if( info.GetDamageType() & DMG_CLUB )
+	{
+		// If clubbed to death, break apart before the attacker's eyes!
+		vecGibVelocity = g_vecAttackDir * -150;
+
+		vecGibAVelocity.x = random->RandomFloat( -2000, 2000 );
+		vecGibAVelocity.y = random->RandomFloat( -2000, 2000 );
+		vecGibAVelocity.z = random->RandomFloat( -2000, 2000 );
+	}
+	else
+	{
+		// Shower the pieces with my velocity.
+		vecGibVelocity = GetCurrentVelocity();
+
+		vecGibAVelocity.x = random->RandomFloat( -500, 500 );
+		vecGibAVelocity.y = random->RandomFloat( -500, 500 );
+		vecGibAVelocity.z = random->RandomFloat( -500, 500 );
+	}
+
+	PropBreakableCreateAll( GetModelIndex(), NULL, GetAbsOrigin(), GetAbsAngles(), vecGibVelocity, vecGibAVelocity, 1.0, 60, COLLISION_GROUP_DEBRIS );
+
+	RemoveDeferred();
+
+	KillSprites( 0.0f );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Explode the manhack if it's damaged while crashing
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+int	CNPC_Manhack::OnTakeDamage_Dying( const CTakeDamageInfo &info )
+{
+	// Ignore damage for the first 1 second of crashing behavior.
+	// If we don't do this, manhacks always just explode under 
+	// sustained fire.
+	VPhysicsTakeDamage( info );
+	
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Turn on the engine sound if we're gagged!
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::OnStateChange( NPC_STATE OldState, NPC_STATE NewState )
+{
+	if( m_vNoiseMod.z == MANHACK_NOISEMOD_HIDE && !(m_spawnflags & SF_NPC_WAIT_FOR_SCRIPT) && !(m_spawnflags & SF_MANHACK_PACKED_UP) )
+	{
+		// This manhack should get a normal noisemod now.
+		float flNoiseMod = random->RandomFloat( 1.7, 2.3 );
+		
+		// Just bob up and down.
+		SetNoiseMod( 0, 0, flNoiseMod );
+	}
+
+	if( NewState != NPC_STATE_IDLE && (m_spawnflags & SF_NPC_GAG) && (m_nEnginePitch1 < 0) )
+	{
+		m_spawnflags &= ~SF_NPC_GAG;
+		SoundInit();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : Type - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::HandleAnimEvent( animevent_t *pEvent )
+{
+	Vector vecNewVelocity;
+	switch( pEvent->event )
+	{
+	case MANHACK_AE_START_ENGINE:
+		StartEye();
+		StartEngine( true );
+		m_spawnflags &= ~SF_MANHACK_PACKED_UP;
+
+		// No bursts until fully unpacked!
+		m_flNextBurstTime = gpGlobals->curtime + FLT_MAX;
+		break;
+
+	case MANHACK_AE_DONE_UNPACKING:
+		m_flNextBurstTime = gpGlobals->curtime + 2.0;
+		break;
+
+	case MANHACK_AE_OPEN_BLADE:
+		m_bBladesActive = true;
+		break;
+
+	default:
+		BaseClass::HandleAnimEvent( pEvent );
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether or not the given activity would translate to flying.
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::IsFlyingActivity( Activity baseAct )
+{
+	return ((baseAct == ACT_FLY || baseAct == ACT_IDLE || baseAct == ACT_RUN || baseAct == ACT_WALK) && m_bBladesActive);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : Type - 
+//-----------------------------------------------------------------------------
+Activity CNPC_Manhack::NPC_TranslateActivity( Activity baseAct )
+{
+	if (IsFlyingActivity( baseAct ))
+	{
+		return (Activity)ACT_FLY;
+	}
+
+	return BaseClass::NPC_TranslateActivity( baseAct );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : Type - 
+//-----------------------------------------------------------------------------
+int CNPC_Manhack::TranslateSchedule( int scheduleType ) 
+{
+	// Fail-safe for deployment if packed up and interrupted
+	if ( m_spawnflags & SF_MANHACK_PACKED_UP )
+	{
+		if ( scheduleType != SCHED_WAIT_FOR_SCRIPT )
+			return SCHED_MANHACK_DEPLOY;
+	}
+
+	switch ( scheduleType )
+	{
+	case SCHED_MELEE_ATTACK1:
+		{
+			return SCHED_MANHACK_ATTACK_HOVER;
+			break;
+		}
+	case SCHED_BACK_AWAY_FROM_ENEMY:
+		{
+			return SCHED_MANHACK_REGROUP;
+			break;
+		}
+	case SCHED_CHASE_ENEMY:
+		{
+			// If we're waiting for our next attack opportunity, just swarm
+			if ( m_flNextBurstTime > gpGlobals->curtime )
+			{
+				return SCHED_MANHACK_SWARM;
+			}
+
+			if ( !m_bDoSwarmBehavior || OccupyStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) )
+			{
+				return SCHED_CHASE_ENEMY;
+			}
+			else
+			{
+				return SCHED_MANHACK_SWARM;
+			}
+		}
+	case SCHED_COMBAT_FACE:
+		{
+			// Don't care about facing enemy, handled automatically
+			return TranslateSchedule( SCHED_CHASE_ENEMY );
+			break;
+		}
+	case SCHED_WAKE_ANGRY:
+		{
+			if( m_spawnflags & SF_MANHACK_PACKED_UP )
+			{
+				return SCHED_MANHACK_DEPLOY;
+			}
+			else
+			{
+				return TranslateSchedule( SCHED_CHASE_ENEMY );
+			}
+			break;
+		}
+
+	case SCHED_IDLE_STAND:
+	case SCHED_ALERT_STAND:
+	case SCHED_ALERT_FACE:
+		{
+			if ( m_pSquad && m_bDoSwarmBehavior )
+			{
+				return SCHED_MANHACK_SWARM_IDLE;
+			}
+			else
+			{
+				return BaseClass::TranslateSchedule(scheduleType);
+			}
+		}
+
+	case SCHED_CHASE_ENEMY_FAILED:
+		{
+			// Relentless bastard! Doesn't fail (fail not valid anyway)
+			return TranslateSchedule( SCHED_CHASE_ENEMY );
+			break;
+		}
+
+	}
+	return BaseClass::TranslateSchedule(scheduleType);
+}
+
+#define MAX_LOITER_DIST_SQR 144 // (12 inches sqr)
+void CNPC_Manhack::Loiter()
+{
+	//NDebugOverlay::Line( GetAbsOrigin(), m_vecLoiterPosition, 255, 255, 255, false, 0.1 );
+
+	// Friendly manhack is loitering.
+	if( !m_bHeld )
+	{
+		float distSqr = m_vecLoiterPosition.DistToSqr(GetAbsOrigin());
+
+		if( distSqr > MAX_LOITER_DIST_SQR )
+		{
+			Vector vecDir = m_vecLoiterPosition - GetAbsOrigin();
+			VectorNormalize( vecDir );
+
+			// Move back to our loiter position.
+			if( gpGlobals->curtime > m_fTimeNextLoiterPulse )
+			{
+				// Apply a pulse of force if allowed right now.
+				if( distSqr > MAX_LOITER_DIST_SQR * 4.0f )
+				{
+					//Msg("Big Pulse\n");
+					m_vForceVelocity = vecDir * 12.0f;
+				}
+				else
+				{
+					//Msg("Small Pulse\n");
+					m_vForceVelocity = vecDir * 6.0f;
+				}
+
+				m_fTimeNextLoiterPulse = gpGlobals->curtime + 1.0f;
+			}
+			else
+			{
+				m_vForceVelocity = vec3_origin;
+			}
+		}
+		else
+		{
+			// Counteract velocity to slow down.
+			Vector velocity = GetCurrentVelocity();
+			m_vForceVelocity = velocity * -0.5;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::MaintainGroundHeight( void )
+{
+	float zSpeed = GetCurrentVelocity().z;
+
+	if ( zSpeed > 32.0f )
+		return;
+
+	const float minGroundHeight = 52.0f;
+
+	trace_t	tr;
+	AI_TraceHull(	GetAbsOrigin(), 
+		GetAbsOrigin() - Vector( 0, 0, minGroundHeight ), 
+		GetHullMins(), 
+		GetHullMaxs(), 
+		(MASK_NPCSOLID_BRUSHONLY), 
+		this, 
+		COLLISION_GROUP_NONE, 
+		&tr );
+
+	if ( tr.fraction != 1.0f )
+	{
+		float speedAdj = MAX( 16, (-zSpeed*0.5f) );
+
+		m_vForceVelocity += Vector(0,0,1) * ( speedAdj * ( 1.0f - tr.fraction ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles movement towards the last move target.
+// Input  : flInterval - 
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::OverrideMove( float flInterval )
+{
+	SpinBlades( flInterval );
+		
+	// Don't execute any move code if packed up.
+	if( HasSpawnFlags(SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED) )
+		return true;
+
+	if( IsLoitering() )
+	{
+		Loiter();
+	}
+	else
+	{
+		MaintainGroundHeight();
+	}
+
+	// So cops, etc. will try to avoid them
+	if ( !HasSpawnFlags( SF_MANHACK_NO_DANGER_SOUNDS ) && !m_bHeld )
+	{
+		CSoundEnt::InsertSound( SOUND_DANGER, GetAbsOrigin(), 75, flInterval, this );
+	}
+
+	// -----------------------------------------------------------------
+	//  If I'm being forced to move somewhere
+	// ------------------------------------------------------------------
+	if (m_fForceMoveTime > gpGlobals->curtime)
+	{
+		MoveToTarget(flInterval, m_vForceMoveTarget);
+	}
+	// -----------------------------------------------------------------
+	// If I have a route, keep it updated and move toward target
+	// ------------------------------------------------------------------
+	else if (GetNavigator()->IsGoalActive())
+	{
+		bool bReducible = GetNavigator()->GetPath()->GetCurWaypoint()->IsReducible();
+		const float strictTolerance = 64.0;
+		//NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, 10 ), 255, 0, 0, true, 0.1);
+  		if ( ProgressFlyPath( flInterval, GetEnemy(), MoveCollisionMask(), bReducible, strictTolerance ) == AINPP_COMPLETE )
+			return true;
+	}
+	// -----------------------------------------------------------------
+	// If I'm supposed to swarm somewhere, try to go there
+	// ------------------------------------------------------------------
+	else if (m_fSwarmMoveTime > gpGlobals->curtime)
+	{
+		MoveToTarget(flInterval, m_vSwarmMoveTarget);
+	}
+	// -----------------------------------------------------------------
+	// If I don't have anything better to do, just decelerate
+	// -------------------------------------------------------------- ----
+	else
+	{
+		float	myDecay	 = 9.5;
+		Decelerate( flInterval, myDecay );
+
+		m_vTargetBanking = vec3_origin;
+
+		// -------------------------------------
+		// If I have an enemy turn to face him
+		// -------------------------------------
+		if (GetEnemy())
+		{
+			TurnHeadToTarget(flInterval, GetEnemy()->EyePosition() );
+		}
+	}
+
+	if ( m_iHealth <= 0 )
+	{
+		// Crashing!!
+		MoveExecute_Dead(flInterval);
+	}
+	else
+	{
+		// Alive!
+		MoveExecute_Alive(flInterval);
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::TurnHeadRandomly(float flInterval )
+{
+	float desYaw = random->RandomFloat(0,360);
+
+	float	iRate	 = 0.8;
+	// Make frame rate independent
+	float timeToUse = flInterval;
+	while (timeToUse > 0)
+	{
+		m_fHeadYaw	   = (iRate * m_fHeadYaw) + (1-iRate)*desYaw;
+		timeToUse = -0.1;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::MoveToTarget(float flInterval, const Vector &vMoveTarget)
+{
+	if (flInterval <= 0)
+	{
+		return;
+	}
+
+	// -----------------------------------------
+	// Don't steer if engine's have stalled
+	// -----------------------------------------
+	if ( gpGlobals->curtime < m_flEngineStallTime || m_iHealth <= 0 )
+		return;
+
+	if ( GetEnemy() != NULL )
+	{
+		TurnHeadToTarget( flInterval, GetEnemy()->EyePosition() );
+	}
+	else
+	{
+		TurnHeadToTarget( flInterval, vMoveTarget );
+	}
+
+	// -------------------------------------
+	// Move towards our target
+	// -------------------------------------
+	float	myAccel;
+	float	myZAccel = 300.0f;
+	float	myDecay	 = 0.3f;
+
+	Vector targetDir;
+	float flDist;
+
+	// If we're bursting, just head straight
+	if ( m_flBurstDuration > gpGlobals->curtime )
+	{
+		float zDist = 500;
+
+		// Steer towards our enemy if we're able to
+		if ( GetEnemy() != NULL )
+		{
+			Vector steerDir = ( GetEnemy()->EyePosition() - GetAbsOrigin() );
+			zDist = fabs( steerDir.z );
+			VectorNormalize( steerDir );
+
+			float useTime = flInterval;
+			while ( useTime > 0.0f )
+			{
+				m_vecBurstDirection += ( steerDir * 4.0f );
+				useTime -= 0.1f;
+			}
+
+			m_vecBurstDirection.z = steerDir.z;
+
+			VectorNormalize( m_vecBurstDirection );
+		}
+
+		// Debug visualizations
+		/*
+		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( targetDir * 64.0f ), 255, 0, 0, true, 2.1f );
+		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( steerDir * 64.0f ), 0, 255, 0, true, 2.1f );
+		NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + ( m_vecBurstDirection * 64.0f ), 0, 0, 255, true, 2.1f );
+		NDebugOverlay::Cross3D( GetAbsOrigin() , -Vector(8,8,8), Vector(8,8,8), 255, 0, 0, true, 2.1f );
+		*/
+
+		targetDir = m_vecBurstDirection;
+
+		flDist	= FLT_MAX;
+		myDecay	 = 0.3f;
+#ifdef _XBOX
+		myAccel	 = 500;
+#else
+		myAccel	 = 400;
+#endif // _XBOX
+		myZAccel = MIN( 500, zDist / flInterval );
+	}
+	else
+	{
+		Vector vecCurrentDir = GetCurrentVelocity();
+		VectorNormalize( vecCurrentDir );
+
+		targetDir = vMoveTarget - GetAbsOrigin();
+		flDist = VectorNormalize( targetDir );
+		
+		float flDot = DotProduct( targetDir, vecCurrentDir );
+
+		// Otherwise we should steer towards our goal
+		if( flDot > 0.25 )
+		{
+			// If my target is in front of me, my flight model is a bit more accurate.
+			myAccel = 300;
+		}
+		else
+		{
+			// Have a harder time correcting my course if I'm currently flying away from my target.
+			myAccel = 200;
+		}
+	}
+
+	// Clamp lateral acceleration
+	if ( myAccel > ( flDist / flInterval ) )
+	{
+		myAccel = flDist / flInterval;
+	}
+
+	/*
+	// Boost vertical movement
+	if ( targetDir.z > 0 )
+	{
+		// Z acceleration is faster when we thrust upwards.
+		// This is to help keep manhacks out of water. 
+		myZAccel *= 5.0;
+	}
+	*/
+
+	// Clamp vertical movement
+	if ( myZAccel > flDist / flInterval )
+	{
+		myZAccel = flDist / flInterval;
+	}
+
+	// Scale by our engine force
+	myAccel *= m_fEnginePowerScale;
+	myZAccel *= m_fEnginePowerScale;
+	
+	MoveInDirection( flInterval, targetDir, myAccel, myZAccel, myDecay );
+
+	// calc relative banking targets
+	Vector forward, right;
+	GetVectors( &forward, &right, NULL );
+	m_vTargetBanking.x	= 40 * DotProduct( forward, targetDir );
+	m_vTargetBanking.z	= 40 * DotProduct( right, targetDir );
+	m_vTargetBanking.y	= 0.0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Ignore water if I'm close to my enemy
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+int CNPC_Manhack::MoveCollisionMask(void)
+{
+	return MASK_NPCSOLID;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Make a splash effect
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Splash( const Vector &vecSplashPos )
+{
+	CEffectData	data;
+
+	data.m_fFlags = 0;
+	data.m_vOrigin = vecSplashPos;
+	data.m_vNormal = Vector( 0, 0, 1 );
+
+	data.m_flScale = 8.0f;
+
+	int contents = GetWaterType();
+
+	// Verify we have valid contents
+	if ( !( contents & (CONTENTS_SLIME|CONTENTS_WATER)))
+	{
+		// We're leaving the water so we have to reverify what it was
+		trace_t	tr;
+		UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 256 ), (CONTENTS_WATER|CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &tr );
+
+		// Re-validate this
+		if ( !(tr.contents&(CONTENTS_WATER|CONTENTS_SLIME)) )
+		{
+			//NOTENOTE: We called a splash but we don't seem to be near water?
+			Assert( 0 );
+			return;
+		}
+
+		contents = tr.contents;
+	}
+	
+	// Mark us if we're in slime
+	if ( contents & CONTENTS_SLIME )
+	{
+		data.m_fFlags |= FX_WATER_IN_SLIME;
+	}
+
+	DispatchEffect( "watersplash", data );
+}
+
+//-----------------------------------------------------------------------------
+// Computes the slice bounce velocity
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::ComputeSliceBounceVelocity( CBaseEntity *pHitEntity, trace_t &tr )
+{
+	if( pHitEntity->IsAlive() && FClassnameIs( pHitEntity, "func_breakable_surf" ) )
+	{
+		// We want to see if the manhack hits a breakable pane of glass. To keep from checking
+		// The classname of the HitEntity on each impact, we only do this check if we hit 
+		// something that's alive. Anyway, prevent the manhack bouncing off the pane of glass,
+		// since this impact will shatter the glass and let the manhack through.
+		return;
+	}
+
+	Vector vecDir;
+	
+	// If the manhack isn't bouncing away from whatever he sliced, force it.
+	VectorSubtract( WorldSpaceCenter(), pHitEntity->WorldSpaceCenter(), vecDir );
+	VectorNormalize( vecDir );
+	vecDir *= 200;
+	vecDir[2] = 0.0f;
+	
+	// Knock it away from us
+	if ( VPhysicsGetObject() != NULL )
+	{
+		VPhysicsGetObject()->ApplyForceOffset( vecDir * 4, GetAbsOrigin() );
+	}
+
+	// Also set our velocity
+	SetCurrentVelocity( vecDir );
+}
+
+
+//-----------------------------------------------------------------------------
+// Is the manhack being held?
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::IsHeldByPhyscannon( )
+{
+	return VPhysicsGetObject() && (VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD);
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose: We've touched something that we can hurt. Slice it!
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Slice( CBaseEntity *pHitEntity, float flInterval, trace_t &tr )
+{
+	// Don't hurt the player if I'm in water
+	if( GetWaterLevel() > 0 && pHitEntity->IsPlayer() )
+		return;
+
+	// Can't slice players holding it with the phys cannon
+	if ( IsHeldByPhyscannon() )
+	{
+		if ( pHitEntity && (pHitEntity == HasPhysicsAttacker( FLT_MAX )) )
+			return;
+	}
+
+	if ( pHitEntity->m_takedamage == DAMAGE_NO )
+		return;
+
+	// Damage must be scaled by flInterval so framerate independent
+	float flDamage = sk_manhack_melee_dmg.GetFloat() * flInterval;
+
+	if ( pHitEntity->IsPlayer() )
+	{
+		flDamage *= 2.0f;
+	}
+	
+	// Held manhacks do more damage
+	if ( IsHeldByPhyscannon() )
+	{
+		// Deal 100 damage/sec
+		flDamage = 100.0f * flInterval;
+	}
+	else if ( pHitEntity->IsNPC() && HasPhysicsAttacker( MANHACK_SMASH_TIME ) )
+	{
+		extern ConVar sk_combine_guard_health;
+		// NOTE: The else here is essential.
+		// The physics attacker *will* be set even when the manhack is held
+		flDamage = sk_combine_guard_health.GetFloat(); // the highest healthed fleshy enemy
+	}
+	else if ( dynamic_cast<CBaseProp*>(pHitEntity) || dynamic_cast<CBreakable*>(pHitEntity) )
+	{
+		// If we hit a prop, we want it to break immediately
+		flDamage = pHitEntity->GetHealth();
+	}
+	else if ( pHitEntity->IsNPC() && IRelationType( pHitEntity ) == D_HT  && FClassnameIs( pHitEntity, "npc_combine_s" ) ) 
+	{
+		flDamage *= 6.0f;
+	}
+
+	if (flDamage < 1.0f)
+	{
+		flDamage = 1.0f;
+	}
+
+	CTakeDamageInfo info( this, this, flDamage, DMG_SLASH );
+
+	// check for actual "ownership" of damage
+	CBasePlayer *pPlayer = HasPhysicsAttacker( MANHACK_SMASH_TIME );
+	if (pPlayer)
+	{
+		info.SetAttacker( pPlayer );
+	}
+
+	Vector dir = (tr.endpos - tr.startpos);
+	if ( dir == vec3_origin )
+	{
+		dir = tr.m_pEnt->GetAbsOrigin() - GetAbsOrigin();
+	}
+	CalculateMeleeDamageForce( &info, dir, tr.endpos );
+	pHitEntity->TakeDamage( info );
+
+	// Spawn some extra blood where we hit
+	if ( pHitEntity->BloodColor() == DONT_BLEED )
+	{
+		CEffectData data;
+		Vector velocity = GetCurrentVelocity();
+
+		data.m_vOrigin = tr.endpos;
+		data.m_vAngles = GetAbsAngles();
+
+		VectorNormalize( velocity );
+		
+		data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;;
+
+		DispatchEffect( "ManhackSparks", data );
+
+		EmitSound( "NPC_Manhack.Grind" );
+
+		//TODO: What we really want to do is get a material reference and emit the proper sprayage! - jdw
+	}
+	else
+	{
+		SpawnBlood(tr.endpos, g_vecAttackDir, pHitEntity->BloodColor(), 6 );
+		EmitSound( "NPC_Manhack.Slice" );
+	}
+
+	// Pop back a little bit after hitting the player
+	ComputeSliceBounceVelocity( pHitEntity, tr );
+
+	// Save off when we last hit something
+	m_flLastDamageTime = gpGlobals->curtime;
+
+	// Reset our state and give the player time to react
+	StopBurst( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've touched something solid. Just bump it.
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Bump( CBaseEntity *pHitEntity, float flInterval, trace_t &tr )
+{
+	if ( !VPhysicsGetObject() )
+		return;
+
+	// Surpressing this behavior
+	if ( m_flBumpSuppressTime > gpGlobals->curtime )
+		return;
+
+	if ( pHitEntity->GetMoveType() == MOVETYPE_VPHYSICS && pHitEntity->Classify()!=CLASS_MANHACK )
+	{
+		HitPhysicsObject( pHitEntity );
+	}
+
+	// We've hit something so deflect our velocity based on the surface
+	// norm of what we've hit
+	if (flInterval > 0)
+	{
+		float moveLen = ( (GetCurrentVelocity() * flInterval) * (1.0 - tr.fraction) ).Length();
+
+		Vector moveVec	= moveLen*tr.plane.normal/flInterval;
+
+		// If I'm totally dead, don't bounce me up
+		if (m_iHealth <=0 && moveVec.z > 0)
+		{
+			moveVec.z = 0;
+		}
+
+		// If I'm right over the ground don't push down
+		if (moveVec.z < 0)
+		{
+			float floorZ = GetFloorZ(GetAbsOrigin());
+			if (abs(GetAbsOrigin().z - floorZ) < 36)
+			{
+				moveVec.z = 0;
+			}
+		}
+
+		Vector myUp;
+		VPhysicsGetObject()->LocalToWorldVector( &myUp, Vector( 0.0, 0.0, 1.0 ) );
+
+		// plane must be something that could hit the blades
+		if (fabs( DotProduct( myUp, tr.plane.normal ) ) < 0.25 )
+		{
+			CEffectData data;
+			Vector velocity = GetCurrentVelocity();
+
+			data.m_vOrigin = tr.endpos;
+			data.m_vAngles = GetAbsAngles();
+
+			VectorNormalize( velocity );
+			
+			data.m_vNormal = ( tr.plane.normal + velocity ) * 0.5;;
+
+			DispatchEffect( "ManhackSparks", data );
+
+			CBroadcastRecipientFilter filter;
+
+			te->DynamicLight( filter, 0.0, &GetAbsOrigin(), 255, 180, 100, 0, 50, 0.3, 150 );
+			
+			// add some spin, but only if we're not already going fast..
+			Vector vecVelocity;
+			AngularImpulse vecAngVelocity;
+			VPhysicsGetObject()->GetVelocity( &vecVelocity, &vecAngVelocity );
+			float flDot = DotProduct( myUp, vecAngVelocity );
+			if ( fabs(flDot) < 100 )
+			{
+				//AngularImpulse torque = myUp * (1000 - flDot * 10);
+				AngularImpulse torque = myUp * (1000 - flDot * 2);
+				VPhysicsGetObject()->ApplyTorqueCenter( torque );
+			}
+			
+			if (!(m_spawnflags	& SF_NPC_GAG))
+			{
+				EmitSound( "NPC_Manhack.Grind" );
+			}
+
+			// For decals and sparks we must trace a line in the direction of the surface norm
+			// that we hit.
+			trace_t	decalTrace;
+			AI_TraceLine( GetAbsOrigin(), GetAbsOrigin() - (tr.plane.normal * 24),MASK_SOLID, this, COLLISION_GROUP_NONE, &decalTrace );
+
+			if ( decalTrace.fraction != 1.0 )
+			{
+				// Leave decal only if colliding horizontally
+				if ((DotProduct(Vector(0,0,1),decalTrace.plane.normal)<0.5) && (DotProduct(Vector(0,0,-1),decalTrace.plane.normal)<0.5))
+				{
+					UTIL_DecalTrace( &decalTrace, "ManhackCut" );
+				}
+			}
+		}
+		
+		// See if we will not have a valid surface
+		if ( tr.allsolid || tr.startsolid )
+		{
+			// Build a fake reflection back along our current velocity because we can't know how to reflect off
+			// a non-existant surface! -- jdw
+
+			Vector vecRandomDir = RandomVector( -1.0f, 1.0f );
+			SetCurrentVelocity( vecRandomDir * 50.0f );
+			m_flBumpSuppressTime = gpGlobals->curtime + 0.5f;
+		}
+		else
+		{
+			// This is a valid hit and we can deflect properly
+			
+			VectorNormalize( moveVec );
+			float hitAngle = -DotProduct( tr.plane.normal, -moveVec );
+
+			Vector vReflection = 2.0 * tr.plane.normal * hitAngle + -moveVec;
+
+			float flSpeed = GetCurrentVelocity().Length();
+			SetCurrentVelocity( GetCurrentVelocity() + vReflection * flSpeed * 0.5f );
+		}
+	}
+
+	// -------------------------------------------------------------
+	// If I'm on a path check LOS to my next node, and fail on path
+	// if I don't have LOS.  Note this is the only place I do this,
+	// so the manhack has to collide before failing on a path
+	// -------------------------------------------------------------
+	if (GetNavigator()->IsGoalActive() && !(GetNavigator()->GetPath()->CurWaypointFlags() & bits_WP_TO_PATHCORNER) )
+	{
+		AIMoveTrace_t moveTrace;
+		GetMoveProbe()->MoveLimit( NAV_GROUND, GetAbsOrigin(), GetNavigator()->GetCurWaypointPos(), 
+			MoveCollisionMask(), GetEnemy(), &moveTrace );
+
+		if (IsMoveBlocked( moveTrace ) && 
+			!moveTrace.pObstruction->ClassMatches( GetClassname() ))
+		{
+			TaskFail(FAIL_NO_ROUTE);
+			GetNavigator()->ClearGoal();
+			return;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::CheckCollisions(float flInterval)
+{
+	// Trace forward to see if I hit anything. But trace forward along the
+	// owner's view direction if you're being carried.
+	Vector vecTraceDir, vecCheckPos;
+	VPhysicsGetObject()->GetVelocity( &vecTraceDir, NULL );
+	vecTraceDir *= flInterval;
+	if ( IsHeldByPhyscannon() )
+	{
+		CBasePlayer *pCarrier = HasPhysicsAttacker( FLT_MAX );
+		if ( pCarrier )
+		{
+			if ( pCarrier->CollisionProp()->CalcDistanceFromPoint( WorldSpaceCenter() ) < 30 )
+			{
+				AngleVectors( pCarrier->EyeAngles(), &vecTraceDir, NULL, NULL );
+				vecTraceDir *= 40.0f;
+			}
+		}
+	}
+
+	VectorAdd( GetAbsOrigin(), vecTraceDir, vecCheckPos );
+	
+	trace_t			tr;
+	CBaseEntity*	pHitEntity = NULL;
+	
+	AI_TraceHull(	GetAbsOrigin(), 
+					vecCheckPos, 
+					GetHullMins(), 
+					GetHullMaxs(),
+					MoveCollisionMask(),
+					this,
+					COLLISION_GROUP_NONE,
+					&tr );
+
+	if ( (tr.fraction != 1.0 || tr.startsolid) && tr.m_pEnt)
+	{
+		PhysicsMarkEntitiesAsTouching( tr.m_pEnt, tr );
+		pHitEntity = tr.m_pEnt;
+
+		if( m_bHeld && tr.m_pEnt->MyNPCPointer() && tr.m_pEnt->MyNPCPointer()->IsPlayerAlly() )
+		{
+			// Don't slice Alyx when she approaches to hack. We need a better solution for this!!
+			//Msg("Ignoring!\n");
+			return;
+		}
+
+		if ( pHitEntity != NULL && 
+			 pHitEntity->m_takedamage == DAMAGE_YES && 
+			 pHitEntity->Classify() != CLASS_MANHACK && 
+			 gpGlobals->curtime > m_flWaterSuspendTime )
+		{
+			// Slice this thing
+			Slice( pHitEntity, flInterval, tr );
+			m_flBladeSpeed = 20.0;
+		}
+		else
+		{
+			// Just bump into this thing.
+			Bump( pHitEntity, flInterval, tr );
+			m_flBladeSpeed = 20.0;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+#define tempTIME_STEP = 0.5;
+void CNPC_Manhack::PlayFlySound(void)
+{
+	float flEnemyDist;
+
+	if( GetEnemy() )
+	{
+		flEnemyDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length();
+	}
+	else
+	{
+		flEnemyDist = FLT_MAX;
+	}
+
+	if( m_spawnflags & SF_NPC_GAG )
+	{
+		// Quiet!
+		return;
+	}
+
+	if( m_flWaterSuspendTime > gpGlobals->curtime )
+	{
+		// Just went in water. Slow the motor!!
+		if( m_bDirtyPitch )
+		{
+			m_nEnginePitch1 = MANHACK_WATER_PITCH1;
+			m_flEnginePitch1Time = gpGlobals->curtime + 0.5f;
+			m_nEnginePitch2 = MANHACK_WATER_PITCH2;
+			m_flEnginePitch2Time = gpGlobals->curtime + 0.5f;
+			m_bDirtyPitch = false;
+		}
+	}
+	// Spin sound based on distance from enemy (unless we're crashing)
+	else if (GetEnemy() && IsAlive() )
+	{
+		if( flEnemyDist < MANHACK_PITCH_DIST1 )
+		{
+			// recalculate pitch.
+			int iPitch1, iPitch2;
+			float flDistFactor;
+
+			flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST1 ); 
+			iPitch1 = MANHACK_MIN_PITCH1 + ( ( MANHACK_MAX_PITCH1 - MANHACK_MIN_PITCH1 ) * flDistFactor); 
+
+			// NOTE: MANHACK_PITCH_DIST2 must be < MANHACK_PITCH_DIST1
+			flDistFactor = MIN( 1.0, 1 - flEnemyDist / MANHACK_PITCH_DIST2 ); 
+			iPitch2 = MANHACK_MIN_PITCH2 + ( ( MANHACK_MAX_PITCH2 - MANHACK_MIN_PITCH2 ) * flDistFactor); 
+
+			m_nEnginePitch1 = iPitch1;
+			m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;
+			m_nEnginePitch2 = iPitch2;
+			m_flEnginePitch2Time = gpGlobals->curtime + 0.1f;
+
+			m_bDirtyPitch = true;
+		}
+		else if( m_bDirtyPitch )
+		{
+			m_nEnginePitch1 = MANHACK_MIN_PITCH1;
+			m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;
+			m_nEnginePitch2 = MANHACK_MIN_PITCH2;
+			m_flEnginePitch2Time = gpGlobals->curtime + 0.2f;
+			m_bDirtyPitch = false;
+		}
+	}
+	// If no enemy just play low sound
+	else if( IsAlive() && m_bDirtyPitch )
+	{
+		m_nEnginePitch1 = MANHACK_MIN_PITCH1;
+		m_flEnginePitch1Time = gpGlobals->curtime + 0.1f;
+		m_nEnginePitch2 = MANHACK_MIN_PITCH2;
+		m_flEnginePitch2Time = gpGlobals->curtime + 0.2f;
+
+		m_bDirtyPitch = false;
+	}
+
+	// Play special engine every once in a while
+	if (gpGlobals->curtime > m_flNextEngineSoundTime && flEnemyDist < 48)
+	{
+		m_flNextEngineSoundTime	= gpGlobals->curtime + random->RandomFloat( 3.0, 10.0 );
+
+		EmitSound( "NPC_Manhack.EngineNoise" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::MoveExecute_Alive(float flInterval)
+{
+	PhysicsCheckWaterTransition();
+
+	Vector	vCurrentVelocity = GetCurrentVelocity();
+
+	// FIXME: move this
+	VPhysicsGetObject()->Wake();
+
+	if( m_fEnginePowerScale < GetMaxEnginePower() && gpGlobals->curtime > m_flWaterSuspendTime )
+	{
+		// Power is low, and we're no longer stuck in water, so bring power up.
+		m_fEnginePowerScale += 0.05;
+	}
+
+	// ----------------------------------------------------------------------------------------
+	// Add time-coherent noise to the current velocity so that it never looks bolted in place.
+	// ----------------------------------------------------------------------------------------
+	float noiseScale = 7.0f;
+
+	if ( (CBaseEntity*)GetEnemy() )
+	{
+		float flDist = (GetAbsOrigin() - GetEnemy()->GetAbsOrigin()).Length2D();
+
+		if( flDist < MANHACK_CHARGE_MIN_DIST )
+		{
+			// Less noise up close.
+			noiseScale = 2.0;
+		}
+
+		if ( IsInEffectiveTargetZone( GetEnemy() ) && flDist < MANHACK_CHARGE_MIN_DIST && gpGlobals->curtime > m_flNextBurstTime )
+		{
+			Vector vecCurrentDir = GetCurrentVelocity();
+			VectorNormalize( vecCurrentDir );
+
+			Vector vecToEnemy = ( GetEnemy()->EyePosition() - WorldSpaceCenter() );
+			VectorNormalize( vecToEnemy );
+
+			float flDot = DotProduct( vecCurrentDir, vecToEnemy );
+
+			if ( flDot > 0.75 )
+			{				
+				Vector offsetDir = ( vecToEnemy - vecCurrentDir );
+				VectorNormalize( offsetDir );
+
+				Vector offsetSpeed = GetCurrentVelocity() * flDot;
+
+				//FIXME: This code sucks -- jdw
+
+				offsetDir.z = 0.0f;
+				m_vForceVelocity += ( offsetDir * ( offsetSpeed.Length2D() * 0.25f ) );
+
+				// Commit to the attack- no steering for about a second
+				StartBurst( vecToEnemy );
+				SetEyeState( MANHACK_EYE_STATE_CHARGE );
+			}
+		}
+		
+		if ( gpGlobals->curtime > m_flBurstDuration )
+		{
+			ShowHostile( false );
+		}
+	}
+
+	// ----------------------------------------------------------------------------------------
+	// Add in any forced velocity
+	// ----------------------------------------------------------------------------------------
+	SetCurrentVelocity( vCurrentVelocity + m_vForceVelocity );
+	m_vForceVelocity = vec3_origin;
+
+	if( !m_bHackedByAlyx || GetEnemy() )
+	{
+		// If hacked and no enemy, don't drift!
+		AddNoiseToVelocity( noiseScale );
+	}
+
+	LimitSpeed( 200, ManhackMaxSpeed() );
+
+	if( m_flWaterSuspendTime > gpGlobals->curtime )
+	{ 
+		if( UTIL_PointContents( GetAbsOrigin() ) & (CONTENTS_WATER|CONTENTS_SLIME) )
+		{
+			// Ooops, we're submerged somehow. Move upwards until our origin is out of the water.
+			m_vCurrentVelocity.z = 20.0;
+		}
+		else
+		{
+			// Skimming the surface. Forbid any movement on Z
+			m_vCurrentVelocity.z = 0.0;
+		}
+	}
+	else if( GetWaterLevel() > 0 )
+	{
+		// Allow the manhack to lift off, but not to go deeper.
+		m_vCurrentVelocity.z = MAX( m_vCurrentVelocity.z, 0 );
+	}
+
+	CheckCollisions(flInterval);
+
+	// Blend out desired velocity when launched by the physcannon
+	if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) && (!IsHeldByPhyscannon()) && VPhysicsGetObject() )
+	{
+		Vector vecCurrentVelocity;
+		VPhysicsGetObject()->GetVelocity( &vecCurrentVelocity, NULL );
+		float flLerpFactor = (gpGlobals->curtime - m_flLastPhysicsInfluenceTime) / MANHACK_SMASH_TIME;
+		flLerpFactor = clamp( flLerpFactor, 0.0f, 1.0f );
+		flLerpFactor = SimpleSplineRemapVal( flLerpFactor, 0.0f, 1.0f, 0.0f, 1.0f );
+		VectorLerp( vecCurrentVelocity, m_vCurrentVelocity, flLerpFactor, m_vCurrentVelocity );
+	}
+
+	QAngle angles = GetLocalAngles();
+
+	// ------------------------------------------
+	//  Stalling
+	// ------------------------------------------
+	if (gpGlobals->curtime < m_flEngineStallTime)
+	{
+		/*
+		// If I'm stalled add random noise
+		angles.x += -20+(random->RandomInt(-10,10));
+		angles.z += -20+(random->RandomInt(0,40));
+
+		TurnHeadRandomly(flInterval);
+		*/
+	}
+	else
+	{
+		// Make frame rate independent
+		float	iRate	 = 0.5;
+		float timeToUse = flInterval;
+		while (timeToUse > 0)
+		{
+			m_vCurrentBanking.x = (iRate * m_vCurrentBanking.x) + (1 - iRate)*(m_vTargetBanking.x);
+			m_vCurrentBanking.z = (iRate * m_vCurrentBanking.z) + (1 - iRate)*(m_vTargetBanking.z);
+			timeToUse = -0.1;
+		}
+		angles.x = m_vCurrentBanking.x;
+		angles.z = m_vCurrentBanking.z;
+		angles.y = 0;
+
+#if 0
+		// Using our steering if we're not otherwise affecting our panels
+		if ( m_flEngineStallTime < gpGlobals->curtime && m_flBurstDuration < gpGlobals->curtime )
+		{
+			Vector delta( 10 * AngleDiff( m_vTargetBanking.x, m_vCurrentBanking.x ), -10 * AngleDiff( m_vTargetBanking.z, m_vCurrentBanking.z ), 0 );
+			//Vector delta( 3 * AngleNormalize( m_vCurrentBanking.x ), -4 * AngleNormalize( m_vCurrentBanking.z ), 0 );
+			VectorYawRotate( delta, -m_fHeadYaw, delta );
+
+			// DevMsg("%.0f %.0f\n", delta.x, delta.y );
+
+			SetPoseParameter( m_iPanel1, -delta.x - delta.y * 2);
+			SetPoseParameter( m_iPanel2, -delta.x + delta.y * 2);
+			SetPoseParameter( m_iPanel3,  delta.x + delta.y * 2);
+			SetPoseParameter( m_iPanel4,  delta.x - delta.y * 2);
+
+			//SetPoseParameter( m_iPanel1, -delta.x );
+			//SetPoseParameter( m_iPanel2, -delta.x );
+			//SetPoseParameter( m_iPanel3, delta.x );
+			//SetPoseParameter( m_iPanel4, delta.x );
+		}
+#endif
+	}
+
+	// SetLocalAngles( angles );
+
+	if( m_lifeState != LIFE_DEAD )
+	{
+		PlayFlySound();
+		// SpinBlades( flInterval );
+		// WalkMove( GetCurrentVelocity() * flInterval, MASK_NPCSOLID );
+	}
+
+//	 NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + Vector(0, 0, -10 ), 0, 255, 0, true, 0.1);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::SpinBlades(float flInterval)
+{
+	if (!m_bBladesActive)
+	{
+		SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF );
+		SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );
+		m_flBladeSpeed = 0.0;
+		m_flPlaybackRate = 1.0;
+		return;
+	}
+
+	if ( IsFlyingActivity( GetActivity() ) )
+	{
+		// Blades may only ramp up while the engine is running
+		if ( m_flEngineStallTime < gpGlobals->curtime )
+		{
+			if (m_flBladeSpeed < 10)
+			{
+				m_flBladeSpeed = m_flBladeSpeed * 2 + 1;
+			}
+			else
+			{
+				// accelerate engine
+				m_flBladeSpeed = m_flBladeSpeed + 80 * flInterval;
+			}
+		}
+
+		if (m_flBladeSpeed > 100)
+		{
+			m_flBladeSpeed = 100;
+		}
+
+		// blend through blades, blades+blur, blur
+		if (m_flBladeSpeed < 20)
+		{
+			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON );
+			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_OFF );
+		}
+		else if (m_flBladeSpeed < 40)
+		{
+			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_ON );
+			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON );
+		}
+		else
+		{
+			SetBodygroup( MANHACK_BODYGROUP_BLADE, MANHACK_BODYGROUP_OFF );
+			SetBodygroup( MANHACK_BODYGROUP_BLUR, MANHACK_BODYGROUP_ON );
+		}
+
+		m_flPlaybackRate = m_flBladeSpeed / 100.0;
+	}
+	else
+	{
+		m_flBladeSpeed = 0.0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Smokes and sparks, exploding periodically. Eventually it goes away.
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::MoveExecute_Dead(float flInterval)
+{
+	if( GetWaterLevel() > 0 )
+	{
+		// No movement if sinking in water.
+		return;
+	}
+
+	// Periodically emit smoke.
+	if (gpGlobals->curtime > m_fSmokeTime && GetWaterLevel() == 0)
+	{
+//		UTIL_Smoke(GetAbsOrigin(), random->RandomInt(10, 15), 10);
+		m_fSmokeTime = gpGlobals->curtime + random->RandomFloat( 0.1, 0.3);
+	}
+
+	// Periodically emit sparks.
+	if (gpGlobals->curtime > m_fSparkTime)
+	{
+		g_pEffects->Sparks( GetAbsOrigin() );
+		m_fSparkTime = gpGlobals->curtime + random->RandomFloat(0.1, 0.3);
+	}
+
+	Vector newVelocity = GetCurrentVelocity();
+
+	// accelerate faster and faster when dying
+	newVelocity = newVelocity + (newVelocity * 1.5 * flInterval );
+
+	// Lose lift
+	newVelocity.z -= 0.02*flInterval*(GetCurrentGravity());
+
+	// ----------------------------------------------------------------------------------------
+	// Add in any forced velocity
+	// ----------------------------------------------------------------------------------------
+	newVelocity += m_vForceVelocity;
+	SetCurrentVelocity( newVelocity );
+	m_vForceVelocity = vec3_origin;
+
+
+	// Lots of noise!! Out of control!
+	AddNoiseToVelocity( 5.0 );
+
+
+	// ----------------------
+	// Limit overall speed
+	// ----------------------
+	LimitSpeed( -1, MANHACK_MAX_SPEED * 2.0 );
+
+	QAngle angles = GetLocalAngles();
+
+	// ------------------------------------------
+	// If I'm dying, add random banking noise
+	// ------------------------------------------
+	angles.x += -20+(random->RandomInt(0,40));
+	angles.z += -20+(random->RandomInt(0,40));
+
+	CheckCollisions(flInterval);
+	PlayFlySound();
+
+	// SetLocalAngles( angles );
+
+	WalkMove( GetCurrentVelocity() * flInterval,MASK_NPCSOLID );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Precache(void)
+{
+	//
+	// Model.
+	//
+	PrecacheModel("models/manhack.mdl");
+	PrecacheModel( MANHACK_GLOW_SPRITE );
+	PropBreakablePrecacheAll( MAKE_STRING("models/manhack.mdl") );
+	
+	PrecacheScriptSound( "NPC_Manhack.Die" );
+	PrecacheScriptSound( "NPC_Manhack.Bat" );
+	PrecacheScriptSound( "NPC_Manhack.Grind" );
+	PrecacheScriptSound( "NPC_Manhack.Slice" );
+	PrecacheScriptSound( "NPC_Manhack.EngineNoise" );
+	PrecacheScriptSound( "NPC_Manhack.Unpack" );
+	PrecacheScriptSound( "NPC_Manhack.ChargeAnnounce" );
+	PrecacheScriptSound( "NPC_Manhack.ChargeEnd" );
+	PrecacheScriptSound( "NPC_Manhack.Stunned" );
+
+	// Sounds used on Client:
+	PrecacheScriptSound( "NPC_Manhack.EngineSound1" );
+	PrecacheScriptSound( "NPC_Manhack.EngineSound2"  );
+	PrecacheScriptSound( "NPC_Manhack.BladeSound" );
+
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::GatherEnemyConditions( CBaseEntity *pEnemy )
+{
+	// The Manhack "regroups" when its in attack range but to
+	// far above or below its enemy.  Set the start attack
+	// condition if we are far enough away from the enemy
+	// or at the correct height
+
+	// Don't bother with Z if the enemy is in a vehicle
+	float fl2DDist = 60.0f;
+	float flZDist = 12.0f;
+
+	if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() )
+	{
+		flZDist = 24.0f;
+	}
+
+	if ((GetAbsOrigin() - pEnemy->GetAbsOrigin()).Length2D() > fl2DDist) 
+	{
+		SetCondition(COND_MANHACK_START_ATTACK);
+	}
+	else
+	{
+		float targetZ	= pEnemy->EyePosition().z;
+		if (fabs(GetAbsOrigin().z - targetZ) < flZDist)
+		{
+			SetCondition(COND_MANHACK_START_ATTACK);
+		}
+	}
+	BaseClass::GatherEnemyConditions(pEnemy);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: For innate melee attack
+// Input  :
+// Output :
+//-----------------------------------------------------------------------------
+int CNPC_Manhack::MeleeAttack1Conditions( float flDot, float flDist )
+{
+	if ( GetEnemy() == NULL )
+		return COND_NONE;
+
+	//TODO: We could also decide if we want to back up here
+	if ( m_flNextBurstTime > gpGlobals->curtime )
+		return COND_NONE;
+
+	float flMaxDist = 45;
+	float flMinDist = 24;
+	bool bEnemyInVehicle = GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle();
+	if ( GetEnemy()->IsPlayer() && assert_cast< CBasePlayer * >(GetEnemy())->IsInAVehicle() )
+	{
+		flMinDist = 0;
+		flMaxDist = 200.0f;
+	}
+
+	if (flDist > flMaxDist)
+	{
+		return COND_TOO_FAR_TO_ATTACK;
+	}
+
+	if (flDist < flMinDist)
+	{
+		return COND_TOO_CLOSE_TO_ATTACK;
+	}
+
+	// Check our current velocity and speed, if it's too far off, we need to settle
+
+	// Don't bother with Z if the enemy is in a vehicle
+	if ( bEnemyInVehicle )
+	{
+		return COND_CAN_MELEE_ATTACK1;
+	}
+
+	// Assume the this check is in regards to my current enemy
+	// for the Manhacks spetial condition
+	float deltaZ = GetAbsOrigin().z - GetEnemy()->EyePosition().z;
+	if ( (deltaZ > 12.0f) || (deltaZ < -24.0f) )
+	{
+		return COND_TOO_CLOSE_TO_ATTACK;
+	}
+
+	return COND_CAN_MELEE_ATTACK1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pTask - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::RunTask( const Task_t *pTask )
+{
+	switch ( pTask->iTask )
+	{
+		// Override this task so we go for the enemy at eye level
+	case TASK_MANHACK_HOVER:
+		{
+			break;
+		}
+
+	// If my enemy has moved significantly, update my path
+	case TASK_WAIT_FOR_MOVEMENT:
+		{
+			CBaseEntity *pEnemy = GetEnemy();
+			if (pEnemy &&
+				(GetCurSchedule()->GetId() == SCHED_CHASE_ENEMY) && 
+				GetNavigator()->IsGoalActive() )
+			{
+				Vector vecEnemyPosition;
+				vecEnemyPosition = pEnemy->EyePosition();
+				if ( GetNavigator()->GetGoalPos().DistToSqr(vecEnemyPosition) > 40 * 40 )
+				{
+					GetNavigator()->UpdateGoalPos( vecEnemyPosition );
+				}
+			}				
+			BaseClass::RunTask(pTask);
+			break;
+		}
+
+	case TASK_MANHACK_MOVEAT_SAVEPOSITION:
+		{
+			// do the movement thingy
+
+//			NDebugOverlay::Line( GetAbsOrigin(), m_vSavePosition, 0, 255, 0, true, 0.1);
+
+			Vector dir = (m_vSavePosition - GetAbsOrigin());
+			float dist = VectorNormalize( dir );
+			float t = m_fSwarmMoveTime - gpGlobals->curtime;
+
+			if (t < 0.1)
+			{
+				if (dist > 256)
+				{
+					TaskFail( FAIL_NO_ROUTE );
+				}
+				else
+				{
+					TaskComplete();
+				}
+			}
+			else if (dist < 64)
+			{
+				m_vSwarmMoveTarget = GetAbsOrigin() - Vector( -dir.y, dir.x, 0 ) * 4;
+			}
+			else
+			{
+				m_vSwarmMoveTarget = GetAbsOrigin() + dir * 10;
+			}
+			break;
+		}
+
+	default:
+		{
+			BaseClass::RunTask(pTask);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::Spawn(void)
+{
+	Precache();
+
+#ifdef _XBOX
+	// Always fade the corpse
+	AddSpawnFlags( SF_NPC_FADE_CORPSE );
+#endif // _XBOX
+
+	SetModel( "models/manhack.mdl" );
+	SetHullType(HULL_TINY_CENTERED); 
+	SetHullSizeNormal();
+
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+
+	if ( HasSpawnFlags( SF_MANHACK_CARRIED ) )
+	{
+		AddSolidFlags( FSOLID_NOT_SOLID );
+		SetMoveType( MOVETYPE_NONE );
+	}
+	else
+	{
+		SetMoveType( MOVETYPE_VPHYSICS );
+	}
+
+	m_iHealth			= sk_manhack_health.GetFloat();
+	SetViewOffset( Vector(0, 0, 10) );		// Position of the eyes relative to NPC's origin.
+	m_flFieldOfView		= VIEW_FIELD_FULL;
+	m_NPCState			= NPC_STATE_NONE;
+
+	if ( m_spawnflags & SF_MANHACK_USE_AIR_NODES)
+	{
+		SetNavType(NAV_FLY);
+	}
+	else
+	{
+		SetNavType(NAV_GROUND);
+	}
+		 
+	AddEFlags( EFL_NO_DISSOLVE | EFL_NO_MEGAPHYSCANNON_RAGDOLL );
+	AddEffects( EF_NOSHADOW );
+
+	SetBloodColor( DONT_BLEED );
+	SetCurrentVelocity( vec3_origin );
+	m_vForceVelocity.Init();
+	m_vCurrentBanking.Init();
+	m_vTargetBanking.Init();
+
+	m_flNextBurstTime	= gpGlobals->curtime;
+
+	CapabilitiesAdd( bits_CAP_INNATE_MELEE_ATTACK1 | bits_CAP_MOVE_FLY | bits_CAP_SQUAD );
+
+	m_flNextEngineSoundTime		= gpGlobals->curtime;
+	m_flWaterSuspendTime		= gpGlobals->curtime;
+	m_flEngineStallTime			= gpGlobals->curtime;
+	m_fForceMoveTime			= gpGlobals->curtime;
+	m_vForceMoveTarget			= vec3_origin;
+	m_fSwarmMoveTime			= gpGlobals->curtime;
+	m_vSwarmMoveTarget			= vec3_origin;
+	m_nLastSpinSound			= -1;
+
+	m_fSmokeTime		= 0;
+	m_fSparkTime		= 0;
+
+	// Set the noise mod to huge numbers right now, in case this manhack starts out waiting for a script
+	// for instance, we don't want him to bob whilst he's waiting for a script. This allows designers
+	// to 'hide' manhacks in small places. (sjb)
+	SetNoiseMod( MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE, MANHACK_NOISEMOD_HIDE );
+
+	// Start out with full power! 
+	m_fEnginePowerScale = GetMaxEnginePower();
+	
+	// find panels
+	m_iPanel1 = LookupPoseParameter( "Panel1" );
+	m_iPanel2 = LookupPoseParameter( "Panel2" );
+	m_iPanel3 = LookupPoseParameter( "Panel3" );
+	m_iPanel4 = LookupPoseParameter( "Panel4" );
+
+	m_fHeadYaw			= 0;
+
+	NPCInit();
+
+	// Manhacks are designed to slam into things, so don't take much damage from it!
+	SetImpactEnergyScale( 0.001 );
+
+	// Manhacks get 30 seconds worth of free knowledge.
+	GetEnemies()->SetFreeKnowledgeDuration( 30.0 );
+	
+	// don't be an NPC, we want to collide with debris stuff
+	SetCollisionGroup( COLLISION_GROUP_NONE );
+
+	m_bHeld = false;
+	m_bHackedByAlyx = false;
+	StopLoitering();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StartEye( void )
+{
+	//Create our Eye sprite
+	if ( m_pEyeGlow == NULL )
+	{
+		m_pEyeGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false );
+		m_pEyeGlow->SetAttachment( this, LookupAttachment( "Eye" ) );
+		
+		if( m_bHackedByAlyx )
+		{
+			m_pEyeGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation );
+			m_pEyeGlow->SetColor( 0, 255, 0 );
+		}
+		else
+		{
+			m_pEyeGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );
+			m_pEyeGlow->SetColor( 255, 0, 0 );
+		}
+
+		m_pEyeGlow->SetBrightness( 164, 0.1f );
+		m_pEyeGlow->SetScale( 0.25f, 0.1f );
+		m_pEyeGlow->SetAsTemporary();
+	}
+
+	//Create our light sprite
+	if ( m_pLightGlow == NULL )
+	{
+		m_pLightGlow = CSprite::SpriteCreate( MANHACK_GLOW_SPRITE, GetLocalOrigin(), false );
+		m_pLightGlow->SetAttachment( this, LookupAttachment( "Light" ) );
+
+		if( m_bHackedByAlyx )
+		{
+			m_pLightGlow->SetTransparency( kRenderTransAdd, 0, 255, 0, 128, kRenderFxNoDissipation );
+			m_pLightGlow->SetColor( 0, 255, 0 );
+		}
+		else
+		{
+			m_pLightGlow->SetTransparency( kRenderTransAdd, 255, 0, 0, 128, kRenderFxNoDissipation );
+			m_pLightGlow->SetColor( 255, 0, 0 );
+		}
+
+		m_pLightGlow->SetBrightness( 164, 0.1f );
+		m_pLightGlow->SetScale( 0.25f, 0.1f );
+		m_pLightGlow->SetAsTemporary();
+	}
+}
+
+//-----------------------------------------------------------------------------
+
+void CNPC_Manhack::Activate()
+{
+	BaseClass::Activate();
+
+	if ( IsAlive() )
+	{
+		StartEye();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the engine sound started. Unless we're not supposed to have it on yet!
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::PostNPCInit( void )
+{
+	// SetAbsVelocity( vec3_origin ); 
+	m_bBladesActive = (m_spawnflags & (SF_MANHACK_PACKED_UP|SF_MANHACK_CARRIED)) ? false : true;
+	BladesInit();
+}
+
+void CNPC_Manhack::BladesInit()
+{
+	if( !m_bBladesActive )
+	{
+		// manhack is packed up, so has no power of its own. 
+		// don't start the engine sounds.
+		// make us fall a little slower than we should, for visual's sake
+		SetGravity( UTIL_ScaleForGravity( 400 ) );
+
+		SetActivity( ACT_IDLE );
+	}
+	else
+	{
+		bool engineSound = (m_spawnflags & SF_NPC_GAG) ? false : true;
+		StartEngine( engineSound );
+		SetActivity( ACT_FLY );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Crank up the engine!
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StartEngine( bool fStartSound )
+{
+	if( fStartSound )
+	{
+		SoundInit();
+	}
+
+	// Make the blade appear.
+	SetBodygroup( 1, 1 );
+
+	// Pop up a little if falling fast!
+	Vector vecVelocity;
+	GetVelocity( &vecVelocity, NULL );
+	if( ( m_spawnflags & SF_MANHACK_PACKED_UP ) && vecVelocity.z < 0 )
+	{
+		// DevMsg(" POP UP \n" );
+		// ApplyAbsVelocityImpulse( Vector(0,0,-vecVelocity.z*0.75) );
+	}
+
+	// Under powered flight now.
+	// SetMoveType( MOVETYPE_STEP );
+	// SetGravity( MANHACK_GRAVITY );
+	AddFlag( FL_FLY );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Start the manhack's engine sound.
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::SoundInit( void )
+{
+	m_nEnginePitch1 = MANHACK_MIN_PITCH1;
+	m_flEnginePitch1Time = gpGlobals->curtime;
+	m_nEnginePitch2 = MANHACK_MIN_PITCH2;
+	m_flEnginePitch2Time = gpGlobals->curtime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StopLoopingSounds(void)
+{
+	BaseClass::StopLoopingSounds();
+	m_nEnginePitch1 = -1;
+	m_flEnginePitch1Time = gpGlobals->curtime;
+	m_nEnginePitch2 = -1;
+	m_flEnginePitch2Time = gpGlobals->curtime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pTask - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StartTask( const Task_t *pTask )
+{
+	switch (pTask->iTask)
+	{	
+	case TASK_MANHACK_UNPACK:
+		{
+			// Just play a sound for now.
+			EmitSound( "NPC_Manhack.Unpack" );
+
+			TaskComplete();
+		}
+		break;
+
+	case TASK_MANHACK_HOVER:
+		break;
+
+	case TASK_MOVE_TO_TARGET_RANGE:
+	case TASK_GET_PATH_TO_GOAL:
+	case TASK_GET_PATH_TO_ENEMY_LKP:
+	case TASK_GET_PATH_TO_PLAYER:
+		{
+			BaseClass::StartTask( pTask );
+			/*
+			// FIXME: why were these tasks considered bad?
+			_asm
+			{
+				int	3;
+				int 5;
+			}
+			*/
+		}
+		break;
+
+	case TASK_FACE_IDEAL:
+		{
+			// this shouldn't ever happen, but if it does, don't choke
+			TaskComplete();
+		}
+		break;
+
+	case TASK_GET_PATH_TO_ENEMY:
+		{
+			if (IsUnreachable(GetEnemy()))
+			{
+				TaskFail(FAIL_NO_ROUTE);
+				return;
+			}
+
+			CBaseEntity *pEnemy = GetEnemy();
+
+			if ( pEnemy == NULL )
+			{
+				TaskFail(FAIL_NO_ENEMY);
+				return;
+			}
+						
+			if ( GetNavigator()->SetGoal( GOALTYPE_ENEMY ) )
+			{
+				TaskComplete();
+			}
+			else
+			{
+				// no way to get there =( 
+				DevWarning( 2, "GetPathToEnemy failed!!\n" );
+				RememberUnreachable(GetEnemy());
+				TaskFail(FAIL_NO_ROUTE);
+			}
+			break;
+		}
+		break;
+
+	case TASK_GET_PATH_TO_TARGET:
+		// DevMsg("TARGET\n");
+		BaseClass::StartTask( pTask );
+		break;
+
+	case TASK_MANHACK_FIND_SQUAD_CENTER:
+		{
+			if (!m_pSquad)
+			{
+				m_vSavePosition = GetAbsOrigin();
+				TaskComplete();
+				break;
+			}
+
+			// calc center of squad
+			int count = 0;
+			m_vSavePosition = Vector( 0, 0, 0 );
+
+			// give attacking members more influence
+			AISquadIter_t iter;
+			for (CAI_BaseNPC *pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) )
+			{
+				if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ))
+				{
+					m_vSavePosition += pSquadMember->GetAbsOrigin() * 10;
+					count += 10;
+				}
+				else
+				{
+					m_vSavePosition += pSquadMember->GetAbsOrigin();
+					count++;
+				}
+			}
+
+			// pull towards enemy
+			if (GetEnemy() != NULL)
+			{
+				m_vSavePosition += GetEnemyLKP() * 4;
+				count += 4;
+			}
+
+			Assert( count != 0 );
+			m_vSavePosition = m_vSavePosition * (1.0 / count);
+
+			TaskComplete();
+		}
+		break;
+
+	case TASK_MANHACK_FIND_SQUAD_MEMBER:
+		{
+			if (m_pSquad)
+			{
+				CAI_BaseNPC *pSquadMember = m_pSquad->GetAnyMember();
+				m_vSavePosition = pSquadMember->GetAbsOrigin();
+
+				// find attacking members
+				AISquadIter_t iter;
+				for (pSquadMember = m_pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = m_pSquad->GetNextMember( &iter ) )
+				{
+					// are they attacking?
+					if (pSquadMember->HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ))
+					{
+						m_vSavePosition = pSquadMember->GetAbsOrigin();
+						break;
+					}
+					// do they have a goal?
+					if (pSquadMember->GetNavigator()->IsGoalActive())
+					{
+						m_vSavePosition = pSquadMember->GetAbsOrigin();
+						break;
+					}
+				}
+			}
+			else
+			{
+				m_vSavePosition = GetAbsOrigin();
+			}
+
+			TaskComplete();
+		}
+		break;
+
+	case TASK_MANHACK_MOVEAT_SAVEPOSITION:
+		{
+			trace_t tr;
+			AI_TraceLine( GetAbsOrigin(), m_vSavePosition, MASK_NPCWORLDSTATIC, this, COLLISION_GROUP_NONE, &tr );
+			if (tr.DidHitWorld())
+			{
+				TaskFail( FAIL_NO_ROUTE );
+			}
+			else
+			{
+				m_fSwarmMoveTime = gpGlobals->curtime + RandomFloat( pTask->flTaskData * 0.8, pTask->flTaskData * 1.2 );
+			}
+		}
+		break;
+
+	default:
+		BaseClass::StartTask(pTask);
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::UpdateOnRemove( void )
+{
+	DestroySmokeTrail();
+	KillSprites( 0.0 );
+	BaseClass::UpdateOnRemove();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:  This is a generic function (to be implemented by sub-classes) to
+//			 handle specific interactions between different types of characters
+//			 (For example the barnacle grabbing an NPC)
+// Input  :  Constant for the type of interaction
+// Output :	 true  - if sub-class has a response for the interaction
+//			 false - if sub-class has no response
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::HandleInteraction(int interactionType, void* data, CBaseCombatCharacter* sourceEnt)
+{
+	if (interactionType == g_interactionVortigauntClaw)
+	{
+		// Freeze so vortigaunt and hit me easier
+
+		m_vForceMoveTarget.x = ((Vector *)data)->x;
+		m_vForceMoveTarget.y = ((Vector *)data)->y;
+		m_vForceMoveTarget.z = ((Vector *)data)->z;
+		m_fForceMoveTime   = gpGlobals->curtime + 2.0;
+		return false;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CNPC_Manhack::ManhackMaxSpeed( void )
+{
+	if( m_flWaterSuspendTime > gpGlobals->curtime )
+	{
+		// Slower in water!
+		return MANHACK_MAX_SPEED * 0.1;
+	}
+
+	if ( HasPhysicsAttacker( MANHACK_SMASH_TIME ) )
+	{
+		return MANHACK_NPC_BURST_SPEED;
+	}
+
+	return MANHACK_MAX_SPEED;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output :
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::ClampMotorForces( Vector &linear, AngularImpulse &angular )
+{
+	float scale = m_flBladeSpeed / 100.0;
+
+	// Msg("%.0f %.0f %.0f\n", linear.x, linear.y, linear.z );
+
+	float fscale = 3000 * scale;
+
+	if ( m_flEngineStallTime > gpGlobals->curtime )
+	{
+		linear.x = 0.0f;
+		linear.y = 0.0f;
+		linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale );
+	}
+	else
+	{
+		// limit reaction forces
+		linear.x = clamp( linear.x, -fscale, fscale );
+		linear.y = clamp( linear.y, -fscale, fscale );
+		linear.z = clamp( linear.z, -fscale, fscale < 1200 ? 1200 : fscale );
+	}
+
+	angular.x *= scale;
+	angular.y *= scale;
+	angular.z *= scale;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::KillSprites( float flDelay )
+{
+	if( m_pEyeGlow )
+	{
+		m_pEyeGlow->FadeAndDie( flDelay );
+		m_pEyeGlow = NULL;
+	}
+
+	if( m_pLightGlow )
+	{
+		m_pLightGlow->FadeAndDie( flDelay );
+		m_pLightGlow = NULL;
+	}
+
+	// Re-enable for light trails
+	/*
+	if ( m_hLightTrail )
+	{
+		m_hLightTrail->FadeAndDie( flDelay );
+		m_hLightTrail = NULL;
+	}
+	*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tests whether we're above the target's feet but also below their top
+// Input  : *pTarget - who we're testing against
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::IsInEffectiveTargetZone( CBaseEntity *pTarget )
+{
+	Vector	vecMaxPos, vecMinPos;
+	float	ourHeight = WorldSpaceCenter().z;
+
+	// If the enemy is in a vehicle, we need to get those bounds
+	if ( pTarget && pTarget->IsPlayer() && assert_cast< CBasePlayer * >(pTarget)->IsInAVehicle() )
+	{
+		CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pTarget)->GetVehicleEntity();
+		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos );
+		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos );
+	
+		if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z )
+			return true;
+
+		return false;
+	}
+	
+	// Get the enemies top and bottom point
+	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,1.0f), &vecMaxPos );
+#ifdef _XBOX
+	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.5f), &vecMinPos ); // Only half the body is valid
+#else
+	pTarget->CollisionProp()->NormalizedToWorldSpace( Vector(0.0f,0.0f,0.0f), &vecMinPos );
+#endif // _XBOX
+	// See if we're within that range
+	if ( ourHeight > vecMinPos.z && ourHeight < vecMaxPos.z )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pEnemy - 
+//			&chasePosition - 
+//			&tolerance - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::TranslateNavGoal( CBaseEntity *pEnemy, Vector &chasePosition )
+{
+	if ( pEnemy && pEnemy->IsPlayer() && assert_cast< CBasePlayer * >(pEnemy)->IsInAVehicle() )
+	{
+		Vector vecNewPos;
+		CBaseEntity *pVehicle = assert_cast< CBasePlayer * >(pEnemy)->GetVehicleEntity();
+		pVehicle->CollisionProp()->NormalizedToWorldSpace( Vector(0.5,0.5,0.5f), &vecNewPos );
+		chasePosition.z = vecNewPos.z;
+	}
+	else
+	{
+		Vector vecTarget;
+		pEnemy->CollisionProp()->NormalizedToCollisionSpace( Vector(0,0,0.75f), &vecTarget );
+		chasePosition.z += vecTarget.z;
+	}
+}
+
+float CNPC_Manhack::GetDefaultNavGoalTolerance()
+{
+	return GetHullWidth();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Input that disables the manhack's swarm behavior
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::InputDisableSwarm( inputdata_t &inputdata )
+{
+	m_bDoSwarmBehavior = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::InputUnpack( inputdata_t &inputdata )
+{
+	if ( HasSpawnFlags( SF_MANHACK_PACKED_UP ) == false )
+		return;
+
+	SetCondition( COND_LIGHT_DAMAGE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPhysGunUser - 
+//			reason - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
+{
+	m_hPhysicsAttacker = pPhysGunUser;
+	m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
+
+	if ( reason == PUNTED_BY_CANNON )
+	{
+		StopLoitering();
+
+		m_bHeld = false;
+
+		// There's about to be a massive change in velocity. 
+		// Think immediately so we can do our slice traces, etc.
+		SetNextThink( gpGlobals->curtime + 0.01f );
+
+		// Stall our engine for awhile
+		m_flEngineStallTime = gpGlobals->curtime + 2.0f;
+		SetEyeState( MANHACK_EYE_STATE_STUNNED );
+	}
+	else
+	{
+		// Suppress collisions between the manhack and the player; we're currently bumping
+		// almost certainly because it's not purely a physics object.
+		SetOwnerEntity( pPhysGunUser );
+		m_bHeld = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPhysGunUser - 
+//			Reason - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
+{
+	// Stop suppressing collisions between the manhack and the player
+	SetOwnerEntity( NULL );
+
+	m_bHeld = false;
+
+	if ( Reason == LAUNCHED_BY_CANNON )
+	{
+		m_hPhysicsAttacker = pPhysGunUser;
+		m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
+
+		// There's about to be a massive change in velocity. 
+		// Think immediately so we can do our slice traces, etc.
+		SetNextThink( gpGlobals->curtime + 0.01f );
+
+		// Stall our engine for awhile
+		m_flEngineStallTime = gpGlobals->curtime + 2.0f;
+		SetEyeState( MANHACK_EYE_STATE_STUNNED );
+	}
+	else
+	{
+		if( m_bHackedByAlyx && !GetEnemy() )
+		{
+			// If a hacked manhack is released in peaceable conditions, 
+			// just loiter, don't zip off.
+			StartLoitering( GetAbsOrigin() );
+		}
+
+		m_hPhysicsAttacker = NULL;
+		m_flLastPhysicsInfluenceTime = 0;
+	}
+}
+
+void CNPC_Manhack::StartLoitering( const Vector &vecLoiterPosition )
+{
+	//Msg("Start Loitering\n");
+
+	m_vTargetBanking = vec3_origin;
+	m_vecLoiterPosition = GetAbsOrigin();
+	m_vForceVelocity = vec3_origin;
+	SetCurrentVelocity( vec3_origin );
+}
+
+CBasePlayer *CNPC_Manhack::HasPhysicsAttacker( float dt )
+{
+	// If the player is holding me now, or I've been recently thrown
+	// then return a pointer to that player
+	if ( IsHeldByPhyscannon() || (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime) )
+	{
+		return m_hPhysicsAttacker;
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Manhacks that have been hacked by Alyx get more engine power (fly faster)
+//-----------------------------------------------------------------------------
+float CNPC_Manhack::GetMaxEnginePower()
+{
+	if( m_bHackedByAlyx )
+	{
+		return 2.0f;
+	}
+
+	return 1.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::UpdatePanels( void )
+{
+	if ( m_flEngineStallTime > gpGlobals->curtime )
+	{
+		SetPoseParameter( m_iPanel1, random->RandomFloat( 0.0f, 90.0f ) );
+		SetPoseParameter( m_iPanel2, random->RandomFloat( 0.0f, 90.0f ) );
+		SetPoseParameter( m_iPanel3, random->RandomFloat( 0.0f, 90.0f ) );
+		SetPoseParameter( m_iPanel4, random->RandomFloat( 0.0f, 90.0f ) );
+		return;
+	}
+
+	float panelPosition = GetPoseParameter( m_iPanel1 );
+
+	if ( m_bShowingHostile )
+	{
+		panelPosition = 90.0f;//UTIL_Approach( 90.0f, panelPosition, 90.0f );
+	}
+	else
+	{
+		panelPosition = UTIL_Approach( 0.0f, panelPosition, 25.0f );
+	}
+
+	//FIXME: If we're going to have all these be equal, there's no need for 4 poses..
+	SetPoseParameter( m_iPanel1, panelPosition );
+	SetPoseParameter( m_iPanel2, panelPosition );
+	SetPoseParameter( m_iPanel3, panelPosition );
+	SetPoseParameter( m_iPanel4, panelPosition );
+
+	//TODO: Make these waver randomly?
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : hostile - 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::ShowHostile( bool hostile /*= true*/)
+{
+	if ( m_bShowingHostile == hostile )
+		return;
+
+	//TODO: Open the manhack panels or close them, depending on the state
+	m_bShowingHostile = hostile;
+
+	if ( hostile )
+	{
+		EmitSound( "NPC_Manhack.ChargeAnnounce" );
+	}
+	else
+	{
+		EmitSound( "NPC_Manhack.ChargeEnd" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StartBurst( const Vector &vecDirection )
+{
+	if ( m_flBurstDuration > gpGlobals->curtime )
+		return;
+
+	ShowHostile();
+
+	// Don't burst attack again for a couple seconds
+	m_flNextBurstTime = gpGlobals->curtime + 2.0;
+	m_flBurstDuration = gpGlobals->curtime + 1.0;
+	
+	// Save off where we were going towards and for how long
+	m_vecBurstDirection = vecDirection;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::StopBurst( bool bInterruptSchedule /*= false*/ )
+{
+	if ( m_flBurstDuration < gpGlobals->curtime )
+		return;
+
+	ShowHostile( false );
+
+	// Stop our burst timers
+	m_flNextBurstTime = gpGlobals->curtime + 2.0f; //FIXME: Skill level based
+	m_flBurstDuration = gpGlobals->curtime - 0.1f;
+
+	if ( bInterruptSchedule )
+	{
+		// We need to rethink our current schedule
+		ClearSchedule( "Stopping burst" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_Manhack::SetEyeState( int state )
+{
+	// Make sure we're active
+	StartEye();
+
+	switch( state )
+	{
+	case MANHACK_EYE_STATE_STUNNED:
+		{
+			if ( m_pEyeGlow )
+			{
+				//Toggle our state
+				m_pEyeGlow->SetColor( 255, 128, 0 );
+				m_pEyeGlow->SetScale( 0.15f, 0.1f );
+				m_pEyeGlow->SetBrightness( 164, 0.1f );
+				m_pEyeGlow->m_nRenderFX = kRenderFxStrobeFast;
+			}
+			
+			if ( m_pLightGlow )
+			{
+				m_pLightGlow->SetColor( 255, 128, 0 );
+				m_pLightGlow->SetScale( 0.15f, 0.1f );
+				m_pLightGlow->SetBrightness( 164, 0.1f );
+				m_pLightGlow->m_nRenderFX = kRenderFxStrobeFast;
+			}
+
+			EmitSound("NPC_Manhack.Stunned");
+
+			break;
+		}
+
+	case MANHACK_EYE_STATE_CHARGE:
+		{
+			if ( m_pEyeGlow )
+			{
+				//Toggle our state
+				if( m_bHackedByAlyx )
+				{
+					m_pEyeGlow->SetColor( 0, 255, 0 );
+				}
+				else
+				{
+					m_pEyeGlow->SetColor( 255, 0, 0 );
+				}
+
+				m_pEyeGlow->SetScale( 0.25f, 0.5f );
+				m_pEyeGlow->SetBrightness( 164, 0.1f );
+				m_pEyeGlow->m_nRenderFX = kRenderFxNone;
+			}
+			
+			if ( m_pLightGlow )
+			{
+				if( m_bHackedByAlyx )
+				{
+					m_pLightGlow->SetColor( 0, 255, 0 );
+				}
+				else
+				{
+					m_pLightGlow->SetColor( 255, 0, 0 );
+				}
+
+				m_pLightGlow->SetScale( 0.25f, 0.5f );
+				m_pLightGlow->SetBrightness( 164, 0.1f );
+				m_pLightGlow->m_nRenderFX = kRenderFxNone;
+			}
+
+			break;
+		}
+	
+	default:
+		if ( m_pEyeGlow )
+			m_pEyeGlow->m_nRenderFX = kRenderFxNone;
+		break;
+	}
+}
+
+
+unsigned int CNPC_Manhack::PhysicsSolidMaskForEntity( void ) const 
+{ 
+	unsigned int mask = BaseClass::PhysicsSolidMaskForEntity();
+	if ( m_bIgnoreClipbrushes )
+	{
+		mask &= ~CONTENTS_MONSTERCLIP;
+	}
+	return mask;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CNPC_Manhack::CreateVPhysics( void )
+{
+	if ( HasSpawnFlags( SF_MANHACK_CARRIED ) )
+		return false;
+
+	return BaseClass::CreateVPhysics();
+}
+
+//-----------------------------------------------------------------------------
+//
+// Schedules
+//
+//-----------------------------------------------------------------------------
+AI_BEGIN_CUSTOM_NPC( npc_manhack, CNPC_Manhack )
+
+	DECLARE_TASK( TASK_MANHACK_HOVER );
+	DECLARE_TASK( TASK_MANHACK_UNPACK );
+	DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_CENTER );
+	DECLARE_TASK( TASK_MANHACK_FIND_SQUAD_MEMBER );
+	DECLARE_TASK( TASK_MANHACK_MOVEAT_SAVEPOSITION );
+
+	DECLARE_CONDITION( COND_MANHACK_START_ATTACK );
+
+	DECLARE_ACTIVITY( ACT_MANHACK_UNPACK );
+
+//=========================================================
+// > SCHED_MANHACK_ATTACK_HOVER
+//=========================================================
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_ATTACK_HOVER,
+
+	"	Tasks"
+	"		TASK_SET_ACTIVITY		ACTIVITY:ACT_FLY"
+	"		TASK_MANHACK_HOVER		0"
+	"	"
+	"	Interrupts"
+	"		COND_TOO_FAR_TO_ATTACK"
+	"		COND_TOO_CLOSE_TO_ATTACK"
+	"		COND_NEW_ENEMY"
+	"		COND_ENEMY_DEAD"
+	"		COND_LIGHT_DAMAGE"
+	"		COND_HEAVY_DAMAGE"
+	"		COND_ENEMY_OCCLUDED"
+);
+
+
+//=========================================================
+// > SCHED_MANHACK_ATTACK_HOVER
+//=========================================================
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_DEPLOY,
+
+	"	Tasks"
+	"		TASK_PLAY_SEQUENCE			ACTIVITY:ACT_MANHACK_UNPACK"
+	"		TASK_SET_ACTIVITY			ACTIVITY:ACT_FLY"
+	"	"
+//	"	Interrupts"
+);
+
+//=========================================================
+// > SCHED_MANHACK_REGROUP
+//=========================================================
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_REGROUP,
+
+	"	Tasks"
+	"		TASK_STOP_MOVING							0"
+	"		TASK_SET_TOLERANCE_DISTANCE					24"
+	"		TASK_STORE_ENEMY_POSITION_IN_SAVEPOSITION	0"
+	"		TASK_FIND_BACKAWAY_FROM_SAVEPOSITION		0"
+	"		TASK_RUN_PATH								0"
+	"		TASK_WAIT_FOR_MOVEMENT						0"
+	"	"
+	"	Interrupts"
+	"		COND_MANHACK_START_ATTACK"
+	"		COND_NEW_ENEMY"
+	"		COND_CAN_MELEE_ATTACK1"
+);
+
+
+
+//=========================================================
+// > SCHED_MANHACK_SWARN
+//=========================================================
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_SWARM_IDLE,
+
+	"	Tasks"
+	"		TASK_STOP_MOVING							0"
+	"		TASK_SET_FAIL_SCHEDULE						SCHEDULE:SCHED_MANHACK_SWARM_FAILURE"
+	"		TASK_MANHACK_FIND_SQUAD_CENTER				0"
+	"		TASK_MANHACK_MOVEAT_SAVEPOSITION			5"
+	"	"
+	"	Interrupts"
+	"		COND_NEW_ENEMY"
+	"		COND_SEE_ENEMY"
+	"		COND_SEE_FEAR"
+	"		COND_LIGHT_DAMAGE"
+	"		COND_HEAVY_DAMAGE"
+	"		COND_SMELL"
+	"		COND_PROVOKED"
+	"		COND_GIVE_WAY"
+	"		COND_HEAR_PLAYER"
+	"		COND_HEAR_DANGER"
+	"		COND_HEAR_COMBAT"
+	"		COND_HEAR_BULLET_IMPACT"
+);
+
+
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_SWARM,
+
+	"	Tasks"
+	"		TASK_STOP_MOVING							0"
+	"		TASK_SET_FAIL_SCHEDULE						SCHEDULE:SCHED_MANHACK_SWARM_FAILURE"
+	"		TASK_MANHACK_FIND_SQUAD_CENTER				0"
+	"		TASK_MANHACK_MOVEAT_SAVEPOSITION			1"
+	"	"
+	"	Interrupts"
+	"		COND_NEW_ENEMY"
+	"		COND_CAN_MELEE_ATTACK1"
+	"		COND_LIGHT_DAMAGE"
+	"		COND_HEAVY_DAMAGE"
+);
+
+DEFINE_SCHEDULE
+(
+	SCHED_MANHACK_SWARM_FAILURE,
+
+	"	Tasks"
+	"		TASK_STOP_MOVING							0"
+	"		TASK_WAIT									2"
+	"		TASK_WAIT_RANDOM							2"
+	"		TASK_MANHACK_FIND_SQUAD_MEMBER				0"
+	"		TASK_GET_PATH_TO_SAVEPOSITION				0"
+	"		TASK_WAIT_FOR_MOVEMENT						0"
+	"	"
+	"	Interrupts"
+	"		COND_SEE_ENEMY"
+	"		COND_NEW_ENEMY"
+);
+
+AI_END_CUSTOM_NPC()