1HEADmaster

1 files changed, 3004 insertions, 0 deletions

diff --git a/game/server/hl2/npc_combinedropship.cpp b/game/server/hl2/npc_combinedropship.cpp
new file mode 100644
index 0000000..ffe1bef
--- /dev/null
+++ b/game/server/hl2/npc_combinedropship.cpp
@@ -0,0 +1,3004 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Large vehicle what delivers combine troops.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "ai_default.h"
+#include "ai_basenpc.h"
+#include "soundenvelope.h"
+#include "cbasehelicopter.h"
+#include "ai_schedule.h"
+#include "engine/IEngineSound.h"
+#include "smoke_trail.h"
+#include "IEffects.h"
+#include "props.h"
+#include "TemplateEntities.h"
+#include "baseanimating.h"
+#include "ai_senses.h"
+#include "entitylist.h"
+#include "ammodef.h"
+#include "ndebugoverlay.h"
+#include "npc_combines.h"
+#include "soundent.h"
+#include "mapentities.h"
+#include "npc_rollermine.h"
+#include "scripted.h"
+#include "explode.h"
+#include "gib.h"
+#include "EntityFlame.h"
+#include "entityblocker.h"
+#include "eventqueue.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// Spawnflags
+#define SF_DROPSHIP_WAIT_FOR_DROPOFF_INPUT		( 1 << 15 )	
+
+#define DROPSHIP_ACCEL_RATE				300
+
+// Timers
+#define DROPSHIP_LANDING_HOVER_TIME		5		// Time to spend on the ground if we have no troops to drop
+#define DROPSHIP_TIME_BETWEEN_MINES		0.5f
+
+// Special actions
+#define DROPSHIP_DEFAULT_SOLDIERS		4
+#define DROPSHIP_MAX_SOLDIERS			6
+
+// Movement
+#define DROPSHIP_BUFF_TIME				0.3f
+#define DROPSHIP_MAX_LAND_TILT			2.5f
+#define DROPSHIP_CONTAINER_HEIGHT		130.0f
+#define DROPSHIP_MAX_SPEED				(60 * 17.6) // 120 miles per hour.
+
+// Pathing data
+#define	DROPSHIP_LEAD_DISTANCE			800.0f
+#define	DROPSHIP_MIN_CHASE_DIST_DIFF	128.0f	// Distance threshold used to determine when a target has moved enough to update our navigation to it
+#define	DROPSHIP_AVOID_DIST				256.0f
+#define DROPSHIP_ARRIVE_DIST			128.0f
+
+#define	CRATE_BBOX_MIN		(Vector( -100, -80, -60 ))
+#define CRATE_BBOX_MAX		(Vector( 100, 80, 80 ))
+
+// Size
+// With crate
+#define DROPSHIP_BBOX_CRATE_MIN		(-Vector(40,40,60))
+#define DROPSHIP_BBOX_CRATE_MAX		(Vector(40,40,40))
+// Without crate
+#define DROPSHIP_BBOX_MIN			(-Vector(40,40,0))
+#define DROPSHIP_BBOX_MAX			(Vector(40,40,40))
+
+// Container gun
+#define DROPSHIP_GUN_SPEED			10		// Rotation speed
+
+#define DROPSHIP_CRATE_ROCKET_HITS	4
+
+enum DROP_STATES 
+{
+	DROP_IDLE = 0,
+	DROP_NEXT,
+};
+
+enum CRATE_TYPES 
+{
+	CRATE_JEEP = -3,
+	CRATE_APC = -2,
+	CRATE_STRIDER = -1,
+	CRATE_ROLLER_HOPPER,
+	CRATE_SOLDIER,
+	CRATE_NONE,
+};
+
+ConVar	g_debug_dropship( "g_debug_dropship", "0" );
+ConVar  sk_dropship_container_health( "sk_dropship_container_health", "750" );
+ConVar	sk_npc_dmg_dropship( "sk_npc_dmg_dropship","5", FCVAR_NONE, "Dropship container cannon damage." );
+
+//=====================================
+// Animation Events
+//=====================================
+#define AE_DROPSHIP_RAMP_OPEN	1		// the tailgate is open.
+
+//=====================================
+// Custom activities
+//=====================================
+// Without Cargo
+Activity ACT_DROPSHIP_FLY_IDLE;			// Flying. Vertical aspect 
+Activity ACT_DROPSHIP_FLY_IDLE_EXAGG;	// Exaggerated version of the flying idle
+// With Cargo
+Activity ACT_DROPSHIP_FLY_IDLE_CARGO;	// Flying. Vertical aspect 
+Activity ACT_DROPSHIP_DESCEND_IDLE;		// waiting to touchdown
+Activity ACT_DROPSHIP_DEPLOY_IDLE;		// idle on the ground with door open. Troops are leaving.
+Activity ACT_DROPSHIP_LIFTOFF;			// transition back to FLY IDLE
+
+enum LandingState_t
+{
+	LANDING_NO = 0,
+
+	// Dropoff
+	LANDING_LEVEL_OUT,		// Heading to a point above the dropoff point
+	LANDING_DESCEND,		// Descending from to the dropoff point
+	LANDING_TOUCHDOWN,
+	LANDING_UNLOADING,
+	LANDING_UNLOADED,
+	LANDING_LIFTOFF,
+
+	// Pickup
+	LANDING_SWOOPING,		// Swooping down to the target
+
+	// Hovering, which we're saying is a type of landing since there's so much landing code to leverage
+	LANDING_START_HOVER,
+	LANDING_HOVER_LEVEL_OUT,
+	LANDING_HOVER_DESCEND,
+	LANDING_HOVER_TOUCHDOWN,
+	LANDING_END_HOVER,
+};
+
+
+#define DROPSHIP_NEAR_SOUND_MIN_DISTANCE 1000
+#define DROPSHIP_NEAR_SOUND_MAX_DISTANCE 2500
+#define DROPSHIP_GROUND_WASH_MIN_ALTITUDE 100.0f
+#define DROPSHIP_GROUND_WASH_MAX_ALTITUDE 750.0f
+
+
+
+//=============================================================================
+// The combine dropship container
+//=============================================================================
+#define DROPSHIP_CONTAINER_MODEL "models/combine_dropship_container.mdl"
+
+#define DROPSHIP_CONTAINER_MAX_CHUNKS	3
+static const char *s_pChunkModelName[DROPSHIP_CONTAINER_MAX_CHUNKS] = 
+{
+	"models/gibs/helicopter_brokenpiece_01.mdl",
+	"models/gibs/helicopter_brokenpiece_02.mdl",
+	"models/gibs/helicopter_brokenpiece_03.mdl",
+};
+
+#define DROPSHIP_CONTAINER_MAX_GIBS	1
+static const char *s_pGibModelName[DROPSHIP_CONTAINER_MAX_GIBS] = 
+{
+	"models/combine_dropship_container.mdl",
+};
+
+class CCombineDropshipContainer : public CPhysicsProp
+{
+	DECLARE_CLASS( CCombineDropshipContainer, CPhysicsProp );
+	DECLARE_DATADESC();
+
+public:
+	void Precache();
+	virtual void Spawn();
+	virtual bool OverridePropdata( void );
+	virtual int OnTakeDamage( const CTakeDamageInfo &info );
+	virtual void Event_Killed( const CTakeDamageInfo &info );
+
+private:
+	enum
+	{
+		MAX_SMOKE_TRAILS = 4,
+		MAX_EXPLOSIONS = 4,
+	};
+
+	// Should we trigger a damage effect?
+	bool ShouldTriggerDamageEffect( int nPrevHealth, int nEffectCount ) const;
+
+	// Add a smoke trail since we've taken more damage
+	void AddSmokeTrail( const Vector &vecPos );
+
+	// Pow!
+	void ThrowFlamingGib();
+
+	// Create a corpse
+	void CreateCorpse();
+
+private:
+	int m_nSmokeTrailCount;
+	EHANDLE m_hLastInflictor;
+	float m_flLastHitTime;
+};
+
+//=============================================================================
+// The combine dropship
+//=============================================================================
+class CNPC_CombineDropship : public CBaseHelicopter
+{
+	DECLARE_CLASS( CNPC_CombineDropship, CBaseHelicopter );
+
+public:
+	~CNPC_CombineDropship();
+
+	// Setup
+	void	Spawn( void );
+	void	Precache( void );
+
+	void	Activate( void );
+
+	// Thinking/init
+	void	InitializeRotorSound( void );
+	void	StopLoopingSounds();
+	void	PrescheduleThink( void );
+
+	// Flight/sound
+	void	Hunt( void );
+	void	Flight( void );
+	float	GetAltitude( void );
+	void	DoRotorWash( void );
+	void	UpdateRotorSoundPitch( int iPitch );
+	void	UpdatePickupNavigation( void );
+	void	UpdateLandTargetNavigation( void );
+	void	CalculateSoldierCount( int iSoldiers );
+
+	// Updates the facing direction
+	virtual void UpdateFacingDirection();
+
+	// Combat
+	void	GatherEnemyConditions( CBaseEntity *pEnemy );
+	void	DoCombatStuff( void );
+	void	SpawnTroop( void );
+	void	DropMine( void );
+	void	UpdateContainerGunFacing( Vector &vecMuzzle, Vector &vecToTarget, Vector &vecAimDir, float *flTargetRange );
+	bool	FireCannonRound( void );
+	void	DoImpactEffect( trace_t &tr, int nDamageType );
+	void	StartCannon( void );
+	void	StopCannon( void );
+	void	MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
+	int		OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo );
+
+	// Input handlers.
+	void	InputLandLeave( inputdata_t &inputdata );
+	void	InputLandTake( inputdata_t &inputdata );
+	void	InputSetLandTarget( inputdata_t &inputdata );
+	void	InputDropMines( inputdata_t &inputdata );
+	void	InputDropStrider( inputdata_t &inputdata );
+	void	InputDropAPC( inputdata_t &inputdata );
+
+	void	InputPickup( inputdata_t &inputdata );
+	void	InputSetGunRange( inputdata_t &inputdata );
+	void	InputNPCFinishDustoff( inputdata_t &inputdata );
+	void	InputStopWaitingForDropoff( inputdata_t &inputdata );
+
+	void	InputHover( inputdata_t &inputdata );
+
+	// From AI_TrackPather
+	virtual void InputFlyToPathTrack( inputdata_t &inputdata );
+
+	Vector	GetDropoffFinishPosition( Vector vecOrigin, CAI_BaseNPC *pNPC, Vector vecMins, Vector vecMaxs );
+	void	LandCommon( bool bHover = false );
+
+	Class_T Classify( void ) { return CLASS_COMBINE_GUNSHIP; }
+
+	// Drop the soldier container
+	void	DropSoldierContainer( );
+
+	// Sounds
+	virtual void UpdateRotorWashVolume();
+
+private:
+	void SetLandingState( LandingState_t landingState );
+	LandingState_t GetLandingState() const { return (LandingState_t)m_iLandState; }
+	bool IsHovering();
+	void UpdateGroundRotorWashSound( float flAltitude );
+	void UpdateRotorWashVolume( CSoundPatch *pRotorSound, float flVolume, float flDeltaTime );
+
+private:
+	// Timers
+	float	m_flTimeTakeOff;
+	float	m_flNextTroopSpawnAttempt;
+	float	m_flDropDelay;			// delta between each mine
+	float	m_flTimeNextAttack;
+	float	m_flLastTime;
+	
+	// States and counters
+	int		m_iMineCount;		// index for current mine # being deployed
+	int		m_totalMinesToDrop;	// total # of mines to drop as a group (based upon triggered input)
+	int		m_soldiersToDrop;
+	int		m_iDropState;
+	int		m_iLandState; 
+	float	m_engineThrust;		// for tracking sound volume/pitch
+	float	m_existPitch;
+	float	m_existRoll;
+	bool	m_bDropMines;		// signal to drop mines
+	bool	m_bIsFiring;
+	int		m_iBurstRounds;
+	bool	m_leaveCrate;
+	bool	m_bHasDroppedOff;
+	int		m_iCrateType;
+	float	m_flLandingSpeed;
+	float	m_flGunRange;
+	bool	m_bInvulnerable;
+
+	QAngle	m_vecAngAcceleration;
+	
+	// Misc Vars
+	CHandle<CBaseAnimating>	m_hContainer;
+	EHANDLE		m_hPickupTarget;
+	int			m_iContainerMoveType;
+	bool		m_bWaitForDropoffInput;
+
+	DECLARE_DATADESC();
+	DEFINE_CUSTOM_AI;
+
+	EHANDLE		m_hLandTarget;
+	string_t	m_iszLandTarget;
+
+	string_t	m_iszAPCVehicleName;
+
+	// Templates for soldier's dropped off
+	string_t	m_sNPCTemplate[ DROPSHIP_MAX_SOLDIERS ];
+	string_t	m_sNPCTemplateData[ DROPSHIP_MAX_SOLDIERS ];	
+	string_t	m_sDustoffPoints[ DROPSHIP_MAX_SOLDIERS ];	
+	int			m_iCurrentTroopExiting;
+	EHANDLE		m_hLastTroopToLeave;
+
+	// Template for rollermines dropped by this dropship
+	string_t	m_sRollermineTemplate;
+	string_t	m_sRollermineTemplateData;
+
+	// Cached attachment points
+	int			m_iMuzzleAttachment;
+	int			m_iMachineGunBaseAttachment;
+	int			m_iMachineGunRefAttachment;
+	int			m_iAttachmentTroopDeploy;
+	int			m_iAttachmentDeployStart;
+
+	// Sounds
+	CSoundPatch		*m_pCannonSound;
+	CSoundPatch		*m_pRotorOnGroundSound;
+	CSoundPatch		*m_pDescendingWarningSound;
+	CSoundPatch		*m_pNearRotorSound;
+
+	// Outputs
+	COutputEvent	m_OnFinishedDropoff;
+	COutputEvent	m_OnFinishedPickup;
+
+	COutputFloat	m_OnContainerShotDownBeforeDropoff;
+	COutputEvent	m_OnContainerShotDownAfterDropoff;
+
+protected:
+	// Because the combine dropship is a leaf class, we can use
+	// static variables to store this information, and save some memory.
+	// Should the dropship end up having inheritors, their activate may
+	// stomp these numbers, in which case you should make these ordinary members
+	// again.
+	static int m_poseBody_Accel, m_poseBody_Sway, m_poseCargo_Body_Accel, m_poseCargo_Body_Sway, 
+		m_poseWeapon_Pitch, m_poseWeapon_Yaw;
+	static bool m_sbStaticPoseParamsLoaded;
+	virtual void	PopulatePoseParameters( void );
+};
+
+bool CNPC_CombineDropship::m_sbStaticPoseParamsLoaded = false;
+
+int CNPC_CombineDropship::m_poseBody_Accel = 0;
+int CNPC_CombineDropship::m_poseBody_Sway = 0;
+int CNPC_CombineDropship::m_poseCargo_Body_Accel = 0;
+int CNPC_CombineDropship::m_poseCargo_Body_Sway = 0;
+int CNPC_CombineDropship::m_poseWeapon_Pitch = 0;
+int CNPC_CombineDropship::m_poseWeapon_Yaw = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: Cache whatever pose parameters we intend to use
+//-----------------------------------------------------------------------------
+void	CNPC_CombineDropship::PopulatePoseParameters( void )
+{
+	if (!m_sbStaticPoseParamsLoaded)
+	{
+		m_poseBody_Accel		= LookupPoseParameter( "body_accel");
+		m_poseBody_Sway			= LookupPoseParameter( "body_sway" );
+		m_poseCargo_Body_Accel  = LookupPoseParameter( "cargo_body_accel" );
+		m_poseCargo_Body_Sway   = LookupPoseParameter( "cargo_body_sway" );
+		m_poseWeapon_Pitch		= LookupPoseParameter( "weapon_pitch" );
+		m_poseWeapon_Yaw		= LookupPoseParameter( "weapon_yaw" );
+
+		m_sbStaticPoseParamsLoaded = true;
+	}
+
+	BaseClass::PopulatePoseParameters();
+}
+
+//------------------------------------------------------------------------------
+//
+// Combine Dropship Container implementation:
+//
+//------------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( prop_dropship_container, CCombineDropshipContainer )
+
+BEGIN_DATADESC( CCombineDropshipContainer )
+
+	DEFINE_FIELD( m_nSmokeTrailCount,	FIELD_INTEGER ),
+	DEFINE_FIELD( m_hLastInflictor,		FIELD_EHANDLE ),
+	DEFINE_FIELD( m_flLastHitTime,		FIELD_TIME ),
+
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Precache 
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::Precache()
+{
+	PrecacheModel( DROPSHIP_CONTAINER_MODEL );
+
+	// Set this here to quiet base prop warnings
+	SetModel( DROPSHIP_CONTAINER_MODEL );
+
+	BaseClass::Precache();
+
+	int i;
+	for ( i = 0; i < DROPSHIP_CONTAINER_MAX_CHUNKS; ++i )
+	{
+		PrecacheModel( s_pChunkModelName[i] );
+	}
+
+	for ( i = 0; i < DROPSHIP_CONTAINER_MAX_GIBS; ++i )
+	{
+		PrecacheModel( s_pGibModelName[i] );
+	}
+
+	PropBreakablePrecacheAll( GetModelName() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Spawn 
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::Spawn()
+{
+	// NOTE: Model must be set before spawn
+	SetModel( DROPSHIP_CONTAINER_MODEL );
+	SetSolid( SOLID_VPHYSICS );
+
+	BaseClass::Spawn();
+
+#ifdef _XBOX
+	AddEffects( EF_NOSHADOW );
+#endif //_XBOX
+
+	m_iHealth = m_iMaxHealth = sk_dropship_container_health.GetFloat();
+}
+
+
+//-----------------------------------------------------------------------------
+// Allows us to use vphysics
+//-----------------------------------------------------------------------------
+bool CCombineDropshipContainer::OverridePropdata( void )
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Should we trigger a damage effect?
+//-----------------------------------------------------------------------------
+inline bool CCombineDropshipContainer::ShouldTriggerDamageEffect( int nPrevHealth, int nEffectCount ) const
+{
+	int nPrevRange = (int)( ((float)nPrevHealth / (float)GetMaxHealth()) * nEffectCount );
+	int nRange = (int)( ((float)GetHealth() / (float)GetMaxHealth()) * nEffectCount );
+	return ( nRange != nPrevRange );
+}
+
+
+//-----------------------------------------------------------------------------
+// Character killed (only fired once)
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::CreateCorpse()
+{
+	m_lifeState = LIFE_DEAD;
+
+	Vector vecNormalizedMins, vecNormalizedMaxs;
+	Vector vecAbsMins, vecAbsMaxs;
+	CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
+	CollisionProp()->WorldToNormalizedSpace( vecAbsMins, &vecNormalizedMins );
+	CollisionProp()->WorldToNormalizedSpace( vecAbsMaxs, &vecNormalizedMaxs );
+
+	// Explode
+	Vector vecAbsPoint;
+	CPASFilter filter( GetAbsOrigin() );
+	CollisionProp()->RandomPointInBounds( vecNormalizedMins, vecNormalizedMaxs, &vecAbsPoint);
+	te->Explosion( filter, 0.0f, &vecAbsPoint, g_sModelIndexFireball, 
+		random->RandomInt( 4, 10 ), random->RandomInt( 8, 15 ), TE_EXPLFLAG_NOPARTICLES, 100, 0 );
+
+	// Break into chunks
+	Vector angVelocity;
+	QAngleToAngularImpulse( GetLocalAngularVelocity(), angVelocity );
+	PropBreakableCreateAll( GetModelIndex(), VPhysicsGetObject(), GetAbsOrigin(), GetAbsAngles(), GetAbsVelocity(), angVelocity, 1.0, 250, COLLISION_GROUP_NPC, this );
+
+	// Create flaming gibs
+	int iChunks = random->RandomInt( 4, 6 );
+	for ( int i = 0; i < iChunks; i++ )
+	{
+		ThrowFlamingGib();
+	}
+
+	AddSolidFlags( FSOLID_NOT_SOLID );
+	AddEffects( EF_NODRAW );
+	UTIL_Remove( this );
+}
+
+
+//-----------------------------------------------------------------------------
+// Character killed (only fired once)
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::ThrowFlamingGib( void )
+{
+	Vector vecAbsMins, vecAbsMaxs;
+	CollisionProp()->WorldSpaceAABB( &vecAbsMins, &vecAbsMaxs );
+
+	Vector vecNormalizedMins, vecNormalizedMaxs;
+	CollisionProp()->WorldToNormalizedSpace( vecAbsMins, &vecNormalizedMins );
+	CollisionProp()->WorldToNormalizedSpace( vecAbsMaxs, &vecNormalizedMaxs );
+
+	Vector vecAbsPoint;
+	CPASFilter filter( GetAbsOrigin() );
+	CollisionProp()->RandomPointInBounds( vecNormalizedMins, vecNormalizedMaxs, &vecAbsPoint);
+
+	// Throw a flaming, smoking chunk.
+	CGib *pChunk = CREATE_ENTITY( CGib, "gib" );
+	pChunk->Spawn( "models/gibs/hgibs.mdl" );
+	pChunk->SetBloodColor( DONT_BLEED );
+
+	QAngle vecSpawnAngles;
+	vecSpawnAngles.Random( -90, 90 );
+	pChunk->SetAbsOrigin( vecAbsPoint );
+	pChunk->SetAbsAngles( vecSpawnAngles );
+
+	int nGib = random->RandomInt( 0, DROPSHIP_CONTAINER_MAX_CHUNKS - 1 );
+	pChunk->Spawn( s_pChunkModelName[nGib] );
+	pChunk->SetOwnerEntity( this );
+	pChunk->m_lifeTime = random->RandomFloat( 6.0f, 8.0f );
+	pChunk->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+	IPhysicsObject *pPhysicsObject = pChunk->VPhysicsInitNormal( SOLID_VPHYSICS, pChunk->GetSolidFlags(), false );
+	
+	// Set the velocity
+	if ( pPhysicsObject )
+	{
+		pPhysicsObject->EnableMotion( true );
+		Vector vecVelocity;
+
+		QAngle angles;
+		angles.x = random->RandomFloat( -20, 20 );
+		angles.y = random->RandomFloat( 0, 360 );
+		angles.z = 0.0f;
+		AngleVectors( angles, &vecVelocity );
+		
+		vecVelocity *= random->RandomFloat( 300, 900 );
+		vecVelocity += GetAbsVelocity();
+
+		AngularImpulse angImpulse;
+		angImpulse = RandomAngularImpulse( -180, 180 );
+
+		pChunk->SetAbsVelocity( vecVelocity );
+		pPhysicsObject->SetVelocity(&vecVelocity, &angImpulse );
+	}
+
+	CEntityFlame *pFlame = CEntityFlame::Create( pChunk, false );
+	if ( pFlame != NULL )
+	{
+		pFlame->SetLifetime( pChunk->m_lifeTime );
+	}
+
+	SmokeTrail *pSmokeTrail =  SmokeTrail::CreateSmokeTrail();
+	if( pSmokeTrail )
+	{
+		pSmokeTrail->m_SpawnRate = 80;
+		pSmokeTrail->m_ParticleLifetime = 0.8f;
+		pSmokeTrail->m_StartColor.Init(0.3, 0.3, 0.3);
+		pSmokeTrail->m_EndColor.Init(0.5, 0.5, 0.5);
+		pSmokeTrail->m_StartSize = 10;
+		pSmokeTrail->m_EndSize = 40;
+		pSmokeTrail->m_SpawnRadius = 5;
+		pSmokeTrail->m_Opacity = 0.4;
+		pSmokeTrail->m_MinSpeed = 15;
+		pSmokeTrail->m_MaxSpeed = 25;
+		pSmokeTrail->SetLifetime( pChunk->m_lifeTime );
+		pSmokeTrail->SetParent( pChunk, 0 );
+		pSmokeTrail->SetLocalOrigin( vec3_origin );
+		pSmokeTrail->SetMoveType( MOVETYPE_NONE );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Character killed (only fired once)
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::Event_Killed( const CTakeDamageInfo &info )
+{
+	if ( GetOwnerEntity() )
+	{
+		CNPC_CombineDropship *pDropship = assert_cast<CNPC_CombineDropship *>(GetOwnerEntity() );
+		pDropship->DropSoldierContainer();
+	}
+
+	CreateCorpse();
+}
+
+
+//-----------------------------------------------------------------------------
+// Damage effects 
+//-----------------------------------------------------------------------------
+int CCombineDropshipContainer::OnTakeDamage( const CTakeDamageInfo &info )
+{
+	if ( m_iHealth == 0 )
+		return 0;
+
+	// Airboat guns + explosive damage is all that can hurt it
+	if (( info.GetDamageType() & (DMG_BLAST | DMG_AIRBOAT) ) == 0 )
+		return 0;
+
+	CTakeDamageInfo dmgInfo = info;
+
+	int nPrevHealth = GetHealth();
+
+	if ( info.GetDamageType() & DMG_BLAST )
+	{
+		// This check is necessary to prevent double-counting of rocket damage
+		// from the blast hitting both the dropship + the container
+		if ( (info.GetInflictor() != m_hLastInflictor) || (gpGlobals->curtime != m_flLastHitTime) )
+		{
+			m_iHealth -= (m_iMaxHealth / DROPSHIP_CRATE_ROCKET_HITS) + 1;
+			m_hLastInflictor = info.GetInflictor();
+			m_flLastHitTime = gpGlobals->curtime; 
+		}
+	}
+	else
+	{
+		m_iHealth -= dmgInfo.GetDamage();
+	}
+
+	if ( m_iHealth <= 0 )
+	{
+		m_iHealth = 0;
+		Event_Killed( dmgInfo );
+		return 0;
+	}
+
+	// Spawn damage effects
+	if ( nPrevHealth != GetHealth() )
+	{
+		if ( ShouldTriggerDamageEffect( nPrevHealth, MAX_SMOKE_TRAILS ) )
+		{
+			AddSmokeTrail( dmgInfo.GetDamagePosition() );
+		}
+
+		if ( ShouldTriggerDamageEffect( nPrevHealth, MAX_EXPLOSIONS ) )
+		{
+			ExplosionCreate( dmgInfo.GetDamagePosition(), vec3_angle, this, 1000, 500.0f, 
+			SF_ENVEXPLOSION_NODAMAGE | SF_ENVEXPLOSION_NOSPARKS | SF_ENVEXPLOSION_NODLIGHTS | SF_ENVEXPLOSION_NOSMOKE, 0 );
+			UTIL_ScreenShake( dmgInfo.GetDamagePosition(), 25.0, 150.0, 1.0, 750.0f, SHAKE_START );
+
+			ThrowFlamingGib();
+		}
+	}
+
+	return 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Add a smoke trail since we've taken more damage
+//-----------------------------------------------------------------------------
+void CCombineDropshipContainer::AddSmokeTrail( const Vector &vecPos )
+{
+	// Start this trail out with a bang!
+	ExplosionCreate( vecPos, vec3_angle, this, 1000, 500.0f, SF_ENVEXPLOSION_NODAMAGE | 
+		SF_ENVEXPLOSION_NOSPARKS | SF_ENVEXPLOSION_NODLIGHTS | SF_ENVEXPLOSION_NOSMOKE, 0 );
+	UTIL_ScreenShake( vecPos, 25.0, 150.0, 1.0, 750.0f, SHAKE_START );
+
+	if ( m_nSmokeTrailCount == MAX_SMOKE_TRAILS )
+		return;
+
+	SmokeTrail *pSmokeTrail =  SmokeTrail::CreateSmokeTrail();
+	if( !pSmokeTrail )
+		return;
+
+	// See if there's an attachment for this smoke trail
+	char buf[32];
+	Q_snprintf( buf, 32, "damage%d", m_nSmokeTrailCount );
+	int nAttachment = LookupAttachment( buf );
+
+	++m_nSmokeTrailCount;
+
+	pSmokeTrail->m_SpawnRate = 20;
+	pSmokeTrail->m_ParticleLifetime = 4.0f;
+	pSmokeTrail->m_StartColor.Init( 0.7f, 0.7f, 0.7f );
+	pSmokeTrail->m_EndColor.Init( 0.6, 0.6, 0.6 );
+	pSmokeTrail->m_StartSize = 15;
+	pSmokeTrail->m_EndSize = 50;
+	pSmokeTrail->m_SpawnRadius = 15;
+	pSmokeTrail->m_Opacity = 0.75f;
+	pSmokeTrail->m_MinSpeed = 10;
+	pSmokeTrail->m_MaxSpeed = 20;
+	pSmokeTrail->m_MinDirectedSpeed	= 100.0f;
+	pSmokeTrail->m_MaxDirectedSpeed	= 120.0f;
+	pSmokeTrail->SetLifetime( 5 );
+	pSmokeTrail->SetParent( this, nAttachment );
+	if ( nAttachment == 0 )
+	{
+		pSmokeTrail->SetAbsOrigin( vecPos );
+	}
+	else
+	{
+		pSmokeTrail->SetLocalOrigin( vec3_origin );
+	}
+
+	Vector vecForward( -1, 0, 0 );
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	pSmokeTrail->SetAbsAngles( angles );
+	pSmokeTrail->SetMoveType( MOVETYPE_NONE );
+}
+
+
+//------------------------------------------------------------------------------
+//
+// Combine Dropship implementation:
+//
+//------------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( npc_combinedropship, CNPC_CombineDropship );
+
+BEGIN_DATADESC( CNPC_CombineDropship )
+
+	DEFINE_FIELD( m_flTimeTakeOff, FIELD_TIME ),
+	DEFINE_FIELD( m_flNextTroopSpawnAttempt, FIELD_TIME ),
+	DEFINE_FIELD( m_flDropDelay, FIELD_TIME ),
+	DEFINE_FIELD( m_flTimeNextAttack, FIELD_TIME ),
+	DEFINE_FIELD( m_flLastTime, FIELD_TIME ),
+	DEFINE_FIELD( m_iMineCount, FIELD_INTEGER ),
+	DEFINE_FIELD( m_totalMinesToDrop, FIELD_INTEGER ),
+	DEFINE_FIELD( m_soldiersToDrop, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iDropState, FIELD_INTEGER ),
+	DEFINE_FIELD( m_bDropMines, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_iLandState, FIELD_INTEGER ),
+	DEFINE_FIELD( m_engineThrust, FIELD_FLOAT ),
+	DEFINE_FIELD( m_bIsFiring, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_iBurstRounds, FIELD_INTEGER ),
+	DEFINE_FIELD( m_existPitch, FIELD_FLOAT ),
+	DEFINE_FIELD( m_existRoll, FIELD_FLOAT ),
+	DEFINE_FIELD( m_leaveCrate, FIELD_BOOLEAN ),
+	DEFINE_KEYFIELD( m_iCrateType, FIELD_INTEGER, "CrateType" ),
+	DEFINE_FIELD( m_flLandingSpeed, FIELD_FLOAT ),
+	DEFINE_KEYFIELD( m_flGunRange, FIELD_FLOAT, "GunRange" ),
+	DEFINE_FIELD( m_vecAngAcceleration,FIELD_VECTOR ),
+	DEFINE_FIELD( m_hContainer, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_hPickupTarget, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_iContainerMoveType, FIELD_INTEGER ),
+	DEFINE_FIELD( m_bWaitForDropoffInput, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_hLandTarget, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_bHasDroppedOff, FIELD_BOOLEAN ),
+	DEFINE_KEYFIELD( m_bInvulnerable, FIELD_BOOLEAN, "Invulnerable" ),
+	DEFINE_KEYFIELD( m_iszLandTarget, FIELD_STRING,	"LandTarget" ),
+	DEFINE_SOUNDPATCH( m_pRotorOnGroundSound ),
+	DEFINE_SOUNDPATCH( m_pDescendingWarningSound ),
+	DEFINE_SOUNDPATCH( m_pNearRotorSound ),
+
+	DEFINE_KEYFIELD( m_iszAPCVehicleName, FIELD_STRING,	"APCVehicleName" ),
+
+	DEFINE_KEYFIELD( m_sRollermineTemplate, FIELD_STRING,	"RollermineTemplate" ),
+	DEFINE_FIELD( m_sRollermineTemplateData, FIELD_STRING ),
+
+	DEFINE_ARRAY( m_sNPCTemplateData, FIELD_STRING, DROPSHIP_MAX_SOLDIERS ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[0], FIELD_STRING,	"NPCTemplate" ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[1], FIELD_STRING,	"NPCTemplate2" ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[2], FIELD_STRING,	"NPCTemplate3" ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[3], FIELD_STRING,	"NPCTemplate4" ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[4], FIELD_STRING,	"NPCTemplate5" ),
+	DEFINE_KEYFIELD( m_sNPCTemplate[5], FIELD_STRING,	"NPCTemplate6" ),
+	// Here to shut classcheck up
+	//DEFINE_ARRAY( m_sNPCTemplate, FIELD_STRING,  DROPSHIP_MAX_SOLDIERS  ),
+	//DEFINE_ARRAY( m_sDustoffPoints, FIELD_STRING,  DROPSHIP_MAX_SOLDIERS  ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[0], FIELD_STRING,	"Dustoff1" ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[1], FIELD_STRING,	"Dustoff2" ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[2], FIELD_STRING,	"Dustoff3" ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[3], FIELD_STRING,	"Dustoff4" ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[4], FIELD_STRING,	"Dustoff5" ),
+	DEFINE_KEYFIELD( m_sDustoffPoints[5], FIELD_STRING,	"Dustoff6" ),
+	DEFINE_FIELD( m_iCurrentTroopExiting, FIELD_INTEGER ),
+	DEFINE_FIELD( m_hLastTroopToLeave, FIELD_EHANDLE ),
+
+	DEFINE_FIELD( m_iMuzzleAttachment, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iMachineGunBaseAttachment, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iMachineGunRefAttachment, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iAttachmentTroopDeploy, FIELD_INTEGER ),
+	DEFINE_FIELD( m_iAttachmentDeployStart , FIELD_INTEGER ),
+
+	DEFINE_SOUNDPATCH( m_pCannonSound ),
+	
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "LandLeaveCrate", InputLandLeave ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "LandTakeCrate", InputLandTake ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "SetLandTarget", InputSetLandTarget ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "DropMines", InputDropMines ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DropStrider", InputDropStrider ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "DropAPC", InputDropAPC ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "Pickup", InputPickup ),
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetGunRange", InputSetGunRange ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "NPCFinishDustoff", InputNPCFinishDustoff ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "StopWaitingForDropoff", InputStopWaitingForDropoff ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "Hover", InputHover ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "FlyToPathTrack", InputFlyToPathTrack ),
+	
+	DEFINE_OUTPUT( m_OnFinishedDropoff, "OnFinishedDropoff" ),
+	DEFINE_OUTPUT( m_OnFinishedPickup, "OnFinishedPickup" ),
+
+	DEFINE_OUTPUT( m_OnContainerShotDownBeforeDropoff, "OnCrateShotDownBeforeDropoff" ),
+	DEFINE_OUTPUT( m_OnContainerShotDownAfterDropoff, "OnCrateShotDownAfterDropoff" ),
+
+END_DATADESC()
+
+
+//------------------------------------------------------------------------------
+// Purpose : Destructor
+//------------------------------------------------------------------------------
+CNPC_CombineDropship::~CNPC_CombineDropship(void)
+{
+	if ( m_hContainer )
+	{
+		UTIL_Remove( m_hContainer );		// get rid of container
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::Spawn( void )
+{
+	Precache( );
+	SetModel( "models/combine_dropship.mdl" );
+
+#ifdef _XBOX
+	AddEffects( EF_NOSHADOW );
+#endif //_XBOX
+
+	InitPathingData( DROPSHIP_ARRIVE_DIST, DROPSHIP_MIN_CHASE_DIST_DIFF, DROPSHIP_AVOID_DIST );
+
+	m_iContainerMoveType = MOVETYPE_NONE;
+	m_iCurrentTroopExiting = 0;
+	m_bHasDroppedOff = false;
+	m_iMuzzleAttachment = -1;
+	m_iMachineGunBaseAttachment = -1;
+	m_iMachineGunRefAttachment = -1;
+	m_iAttachmentTroopDeploy = -1;
+	m_iAttachmentDeployStart = -1;
+
+	// create the correct bin for the ship to carry
+	switch ( m_iCrateType )
+	{
+	case CRATE_ROLLER_HOPPER:
+		break;
+
+	case CRATE_SOLDIER:
+		m_hContainer = (CBaseAnimating*)CreateEntityByName( "prop_dropship_container" );
+		if ( m_hContainer )
+		{
+			m_hContainer->SetName( AllocPooledString("dropship_container") );
+			m_hContainer->SetAbsOrigin( GetAbsOrigin() );
+			m_hContainer->SetAbsAngles( GetAbsAngles() );
+			m_hContainer->SetParent(this, 0);
+			m_hContainer->SetOwnerEntity(this);
+			m_hContainer->Spawn();
+
+			IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+			if ( pPhysicsObject )
+			{
+				pPhysicsObject->SetShadow( 1e4, 1e4, false, false );
+				pPhysicsObject->UpdateShadow( m_hContainer->GetAbsOrigin(), m_hContainer->GetAbsAngles(), false, 0 );
+			}
+
+			m_hContainer->SetMoveType( MOVETYPE_PUSH );
+			m_hContainer->SetGroundEntity( NULL );
+
+			// Cache off container's attachment points
+			m_iAttachmentTroopDeploy = m_hContainer->LookupAttachment( "deploy_landpoint" );
+			m_iAttachmentDeployStart = m_hContainer->LookupAttachment( "Deploy_Start" );
+			m_iMuzzleAttachment = m_hContainer->LookupAttachment( "muzzle" );
+			m_iMachineGunBaseAttachment = m_hContainer->LookupAttachment( "gun_base" );
+			// NOTE: gun_ref must have the same position as gun_base, but rotates with the gun
+			m_iMachineGunRefAttachment = m_hContainer->LookupAttachment( "gun_ref" );
+		}
+		break;
+
+	case CRATE_STRIDER:
+		m_hContainer = (CBaseAnimating*)CreateEntityByName( "npc_strider" );
+		m_hContainer->SetAbsOrigin( GetAbsOrigin() - Vector( 0, 0 , 100 ) );
+		m_hContainer->SetAbsAngles( GetAbsAngles() );
+		m_hContainer->SetParent(this, 0);
+		m_hContainer->SetOwnerEntity(this);
+		m_hContainer->Spawn();
+		m_hContainer->SetAbsOrigin( GetAbsOrigin() - Vector( 0, 0 , 100 ) );
+		break;
+
+	case CRATE_APC:
+		{
+			m_soldiersToDrop = 0;
+			m_hContainer = (CBaseAnimating*)gEntList.FindEntityByName( NULL, m_iszAPCVehicleName );
+			if ( !m_hContainer )
+			{
+				Warning("Unable to find APC %s\n", STRING( m_iszAPCVehicleName ) ); 		
+				break;
+			}
+
+			Vector apcPosition = GetAbsOrigin() - Vector( 0, 0 , 25 );
+			QAngle apcAngles = GetAbsAngles();
+			VMatrix mat, rot, result;
+			MatrixFromAngles( apcAngles, mat );
+			MatrixBuildRotateZ( rot, -90 );
+			MatrixMultiply( mat, rot, result );
+			MatrixToAngles( result, apcAngles );
+
+			m_hContainer->Teleport( &apcPosition, &apcAngles, NULL );
+
+			m_iContainerMoveType = m_hContainer->GetMoveType();
+
+			IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+			if ( pPhysicsObject )
+			{
+				pPhysicsObject->SetShadow( 1e4, 1e4, false, false );
+			}
+
+			m_hContainer->SetParent(this, 0);
+			m_hContainer->SetOwnerEntity(this);
+			m_hContainer->SetMoveType( MOVETYPE_PUSH );
+			m_hContainer->SetGroundEntity( NULL );
+			m_hContainer->UpdatePhysicsShadowToCurrentPosition(0);
+		}
+		break;
+
+	case CRATE_JEEP:
+		m_hContainer = (CBaseAnimating*)CreateEntityByName( "prop_dynamic_override" );
+		if ( m_hContainer )
+		{
+			m_hContainer->SetModel( "models/buggy.mdl" );
+			m_hContainer->SetName( AllocPooledString("dropship_jeep") );
+
+			m_hContainer->SetAbsOrigin( GetAbsOrigin() );//- Vector( 0, 0 , 25 ) );
+			QAngle angles = GetAbsAngles();
+			VMatrix mat, rot, result;
+			MatrixFromAngles( angles, mat );
+			MatrixBuildRotateZ( rot, -90 );
+			MatrixMultiply( mat, rot, result );
+			MatrixToAngles( result, angles );
+			m_hContainer->SetAbsAngles( angles );
+
+			m_hContainer->SetParent(this, 0);
+			m_hContainer->SetOwnerEntity(this);
+			m_hContainer->SetSolid( SOLID_VPHYSICS );
+			m_hContainer->Spawn();
+		}
+		break;
+
+	case CRATE_NONE:
+	default:
+		break;
+	}
+
+	// Setup our bbox
+	if ( m_hContainer )
+	{
+		UTIL_SetSize( this, DROPSHIP_BBOX_CRATE_MIN, DROPSHIP_BBOX_CRATE_MAX );
+		SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_CARGO );
+	}
+	else
+	{
+		UTIL_SetSize( this, DROPSHIP_BBOX_MIN, DROPSHIP_BBOX_MAX );
+		SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_EXAGG );
+	}
+
+	m_cullBoxMins = WorldAlignMins() - Vector(300,300,200);
+	m_cullBoxMaxs = WorldAlignMaxs() + Vector(300,300,200);
+	BaseClass::Spawn();
+
+	// Dropship ignores all damage, but can deal it to its carried container
+	m_takedamage = m_bInvulnerable ? DAMAGE_NO : DAMAGE_YES;
+	if ( m_bInvulnerable && m_hContainer )
+	{
+		m_hContainer->m_takedamage = DAMAGE_NO;
+	}
+
+	m_iHealth = 100;
+	m_flFieldOfView = 0.5; // 60 degrees
+	m_iBurstRounds = 15;
+
+	InitBoneControllers();
+	InitCustomSchedules();
+
+	m_flMaxSpeed = DROPSHIP_MAX_SPEED;
+	m_flMaxSpeedFiring = BASECHOPPER_MAX_FIRING_SPEED;
+	m_hPickupTarget = NULL;
+	m_hLandTarget = NULL;
+
+	//!!!HACKHACK
+	// This tricks the AI code that constantly complains that the vehicle has no schedule.
+	SetSchedule( SCHED_IDLE_STAND );
+
+	SetLandingState( LANDING_NO );
+
+	if ( HasSpawnFlags( SF_DROPSHIP_WAIT_FOR_DROPOFF_INPUT ) )
+	{
+		m_bWaitForDropoffInput = true;
+	}
+	else
+	{
+		m_bWaitForDropoffInput = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called after spawning on map load or on a load from save game.
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::Activate( void )
+{
+	BaseClass::Activate();
+
+	if ( !m_sRollermineTemplateData )
+	{
+		m_sRollermineTemplateData = NULL_STRING;
+		if ( m_sRollermineTemplate != NULL_STRING )
+		{
+			// This must be the first time we're activated, not a load from save game.
+			// Look up the template in the template database.
+			m_sRollermineTemplateData = Templates_FindByTargetName(STRING(m_sRollermineTemplate));
+			if ( m_sRollermineTemplateData == NULL_STRING )
+			{
+				Warning( "npc_combinedropship %s: Rollermine Template %s not found!\n", STRING(GetEntityName()), STRING(m_sRollermineTemplate) );
+			}
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::Precache( void )
+{
+	// Models
+	PrecacheModel("models/combine_dropship.mdl");
+	switch ( m_iCrateType )
+	{
+	case CRATE_SOLDIER:
+		UTIL_PrecacheOther( "prop_dropship_container" );
+
+		//
+		// Precache the all templates that we are configured to spawn
+		//
+		for ( int i = 0; i < DROPSHIP_MAX_SOLDIERS; i++ )
+		{
+			if ( m_sNPCTemplate[i] != NULL_STRING )
+			{
+				if ( m_sNPCTemplateData[i] == NULL_STRING )
+				{
+					m_sNPCTemplateData[i] = Templates_FindByTargetName(STRING(m_sNPCTemplate[i]));
+				}
+				if ( m_sNPCTemplateData[i] != NULL_STRING )
+				{
+					CBaseEntity *pEntity = NULL;
+					MapEntity_ParseEntity( pEntity, STRING(m_sNPCTemplateData[i]), NULL );
+					if ( pEntity != NULL )
+					{
+						pEntity->Precache();
+						UTIL_RemoveImmediate( pEntity );
+					}
+				}
+				else
+				{
+					Warning( "npc_combinedropship %s: Template NPC %s not found!\n", STRING(GetEntityName()), STRING(m_sNPCTemplate[i]) );
+
+					// Use the first template we've got
+					m_sNPCTemplateData[i] = m_sNPCTemplateData[0];
+				}
+
+				// Make sure we've got a dustoff point for it
+				if ( m_sDustoffPoints[i] == NULL_STRING )
+				{
+					Warning( "npc_combinedropship %s: Has no dustoff point for NPC %d!\n", STRING(GetEntityName()), i );
+				}
+			}
+			else
+			{
+				m_sNPCTemplateData[i] = NULL_STRING;
+			}
+		}
+		break;
+
+	case CRATE_JEEP:
+		PrecacheModel("models/buggy.mdl");
+		break;
+
+	default:
+		break;
+	}
+
+	PrecacheScriptSound( "NPC_CombineDropship.RotorLoop" );
+	PrecacheScriptSound( "NPC_CombineDropship.FireLoop" );
+	PrecacheScriptSound( "NPC_CombineDropship.NearRotorLoop" );
+	PrecacheScriptSound( "NPC_CombineDropship.OnGroundRotorLoop" );
+	PrecacheScriptSound( "NPC_CombineDropship.DescendingWarningLoop" );
+	PrecacheScriptSound( "NPC_CombineDropship.NearRotorLoop" );
+
+	if ( m_sRollermineTemplate != NULL_STRING )
+	{
+		UTIL_PrecacheOther( "npc_rollermine" );
+	}
+
+	BaseClass::Precache();
+
+}
+
+//------------------------------------------------------------------------------
+// Purpose : 
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::Flight( void )
+{
+	// Only run the flight model in some flight states
+	bool bRunFlight = ( GetLandingState() == LANDING_NO || 
+							GetLandingState() == LANDING_LEVEL_OUT || 
+							GetLandingState() == LANDING_LIFTOFF ||
+							GetLandingState() == LANDING_SWOOPING ||
+							GetLandingState() == LANDING_DESCEND ||
+							GetLandingState() == LANDING_HOVER_LEVEL_OUT ||
+							GetLandingState() == LANDING_HOVER_DESCEND );
+
+	Vector forward, right, up;
+	GetVectors( &forward, &right, &up );
+
+	float finspeed = 0;
+	float swayspeed = 0;
+	Vector vecImpulse = vec3_origin;
+
+	//Adrian: Slowly lerp the orientation and position of the cargo into place...
+	//We assume CRATE_NONE means the dropship just picked up some random phys object.
+	if ( m_hContainer != NULL && ( m_iCrateType == CRATE_SOLDIER || m_iCrateType == CRATE_NONE ) )
+	{
+		if ( m_hContainer->GetLocalOrigin() != vec3_origin )
+		{
+			Vector vCurrentLocalOrigin = m_hContainer->GetLocalOrigin();
+			Vector vLocalOrigin;
+	
+			VectorLerp( vCurrentLocalOrigin, vec3_origin, 0.05f, vLocalOrigin );
+	
+			m_hContainer->SetLocalOrigin( vLocalOrigin );
+		}
+
+		if ( m_hContainer->GetLocalAngles() != vec3_angle )
+		{
+			QAngle vCurrentLocalAngles = m_hContainer->GetLocalAngles();
+			QAngle vLocalAngles;
+
+			vLocalAngles = Lerp( 0.05f, vCurrentLocalAngles, vec3_angle );
+
+			m_hContainer->SetLocalAngles( vLocalAngles );
+		}
+	}
+
+	if ( bRunFlight )
+	{
+		if( GetFlags() & FL_ONGROUND )
+		{
+			// This would be really bad.
+			SetGroundEntity( NULL );
+		}
+
+		// calc desired acceleration
+		float dt = 1.0f;
+
+		Vector	accel;
+		float	accelRate = DROPSHIP_ACCEL_RATE;
+		float	maxSpeed = GetMaxSpeed();
+
+		if ( m_lifeState == LIFE_DYING )
+		{
+			accelRate *= 5.0;
+			maxSpeed *= 5.0;
+		}
+
+		float flCurrentSpeed = GetAbsVelocity().Length();
+		float flDist = MIN( flCurrentSpeed + accelRate, maxSpeed );
+
+		Vector deltaPos;
+		if ( GetLandingState() == LANDING_SWOOPING )
+		{
+			// Move directly to the target point
+			deltaPos = GetDesiredPosition();
+		}
+		else
+		{
+			ComputeActualTargetPosition( flDist, dt, 0.0f, &deltaPos );
+		}
+		deltaPos -= GetAbsOrigin();
+
+		//NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + deltaPos, 0, 255, 0, true, 0.1f );
+
+		// calc goal linear accel to hit deltaPos in dt time.
+		accel.x = 2.0 * (deltaPos.x - GetAbsVelocity().x * dt) / (dt * dt);
+		accel.y = 2.0 * (deltaPos.y - GetAbsVelocity().y * dt) / (dt * dt);
+		accel.z = 2.0 * (deltaPos.z - GetAbsVelocity().z * dt + 0.5 * 384 * dt * dt) / (dt * dt);
+		
+		float flDistFromPath = 0.0f;
+		Vector vecPoint, vecDelta;
+		if ( IsOnPathTrack() && GetLandingState() == LANDING_NO )
+		{
+			// Also, add in a little force to get us closer to our current line segment if we can
+			ClosestPointToCurrentPath( &vecPoint );
+			VectorSubtract( vecPoint, GetAbsOrigin(), vecDelta );
+ 			flDistFromPath = VectorNormalize( vecDelta );
+			if ( flDistFromPath > 200 )
+			{
+				// Strongly constrain to an n unit pipe around the current path
+				// by damping out all impulse forces that would push us further from the pipe
+				float flAmount = (flDistFromPath - 200) / 200.0f;
+				flAmount = clamp( flAmount, 0, 1 );
+				VectorMA( accel, flAmount * 200.0f, vecDelta, accel );
+			}
+		}
+
+		// don't fall faster than 0.2G or climb faster than 2G
+		accel.z = clamp( accel.z, 384 * 0.2, 384 * 2.0 );
+
+		Vector goalUp = accel;
+		VectorNormalize( goalUp );
+
+		// calc goal orientation to hit linear accel forces
+		float goalPitch = RAD2DEG( asin( DotProduct( forward, goalUp ) ) );
+		float goalYaw = UTIL_VecToYaw( m_vecDesiredFaceDir );
+		float goalRoll = RAD2DEG( asin( DotProduct( right, goalUp ) ) );
+
+		// clamp goal orientations
+		goalPitch = clamp( goalPitch, -45, 60 );
+		goalRoll = clamp( goalRoll, -45, 45 );
+
+		// calc angular accel needed to hit goal pitch in dt time.
+		dt = 0.6;
+		QAngle goalAngAccel;
+		goalAngAccel.x = 2.0 * (AngleDiff( goalPitch, AngleNormalize( GetLocalAngles().x ) ) - GetLocalAngularVelocity().x * dt) / (dt * dt);
+		goalAngAccel.y = 2.0 * (AngleDiff( goalYaw, AngleNormalize( GetLocalAngles().y ) ) - GetLocalAngularVelocity().y * dt) / (dt * dt);
+		goalAngAccel.z = 2.0 * (AngleDiff( goalRoll, AngleNormalize( GetLocalAngles().z ) ) - GetLocalAngularVelocity().z * dt) / (dt * dt);
+
+		goalAngAccel.x = clamp( goalAngAccel.x, -300, 300 );
+		//goalAngAccel.y = clamp( goalAngAccel.y, -60, 60 );
+		goalAngAccel.y = clamp( goalAngAccel.y, -120, 120 );
+		goalAngAccel.z = clamp( goalAngAccel.z, -300, 300 );
+
+		// limit angular accel changes to simulate mechanical response times
+		dt = 0.1;
+		QAngle angAccelAccel;
+		angAccelAccel.x = (goalAngAccel.x - m_vecAngAcceleration.x) / dt;
+		angAccelAccel.y = (goalAngAccel.y - m_vecAngAcceleration.y) / dt;
+		angAccelAccel.z = (goalAngAccel.z - m_vecAngAcceleration.z) / dt;
+
+		angAccelAccel.x = clamp( angAccelAccel.x, -1000, 1000 );
+		angAccelAccel.y = clamp( angAccelAccel.y, -1000, 1000 );
+		angAccelAccel.z = clamp( angAccelAccel.z, -1000, 1000 );
+
+		m_vecAngAcceleration += angAccelAccel * 0.1;
+
+		// DevMsg( "pitch %6.1f (%6.1f:%6.1f)  ", goalPitch, GetLocalAngles().x, m_vecAngVelocity.x );
+		// DevMsg( "roll %6.1f (%6.1f:%6.1f) : ", goalRoll, GetLocalAngles().z, m_vecAngVelocity.z );
+		// DevMsg( "%6.1f %6.1f %6.1f  :  ", goalAngAccel.x, goalAngAccel.y, goalAngAccel.z );
+		// DevMsg( "%6.0f %6.0f %6.0f\n", angAccelAccel.x, angAccelAccel.y, angAccelAccel.z );
+
+		ApplySidewaysDrag( right );
+		ApplyGeneralDrag();
+		
+		QAngle angVel = GetLocalAngularVelocity();
+		angVel += m_vecAngAcceleration * 0.1;
+
+		//angVel.y = clamp( angVel.y, -60, 60 );
+		//angVel.y = clamp( angVel.y, -120, 120 );
+		angVel.y = clamp( angVel.y, -120, 120 );
+
+		SetLocalAngularVelocity( angVel );
+
+		m_flForce = m_flForce * 0.8 + (accel.z + fabs( accel.x ) * 0.1 + fabs( accel.y ) * 0.1) * 0.1 * 0.2;
+
+		vecImpulse = m_flForce * up;
+		
+		if ( m_lifeState == LIFE_DYING )
+		{
+			vecImpulse.z = -38.4;  // 64ft/sec
+		}
+		else
+		{
+			vecImpulse.z -= 38.4;  // 32ft/sec
+		}
+
+		// Find our current velocity
+		Vector vecVelDir = GetAbsVelocity();
+
+		VectorNormalize( vecVelDir );
+
+		if ( flDistFromPath > 100 )
+		{
+			// Strongly constrain to an n unit pipe around the current path
+			// by damping out all impulse forces that would push us further from the pipe
+			float flDot = DotProduct( vecImpulse, vecDelta );
+			if ( flDot < 0.0f )
+			{
+				VectorMA( vecImpulse, -flDot * 0.1f, vecDelta, vecImpulse );
+			}
+
+			// Also apply an extra impulse to compensate for the current velocity
+			flDot = DotProduct( vecVelDir, vecDelta );
+			if ( flDot < 0.0f )
+			{
+				VectorMA( vecImpulse, -flDot * 0.1f, vecDelta, vecImpulse );
+			}
+		}
+		
+		// Find our acceleration direction
+		Vector	vecAccelDir = vecImpulse;
+		VectorNormalize( vecAccelDir );
+
+		// Level out our plane of movement
+		vecAccelDir.z	= 0.0f;
+		vecVelDir.z		= 0.0f;
+		forward.z		= 0.0f;
+		right.z			= 0.0f;
+
+		// Find out how "fast" we're moving in relation to facing and acceleration
+		finspeed = m_flForce * DotProduct( vecVelDir, vecAccelDir );
+		swayspeed = m_flForce * DotProduct( vecVelDir, right );
+	}
+
+	// Use the correct pose params for the state of our container
+	int poseBodyAccel;
+	int poseBodySway;
+	if ( m_hContainer || GetLandingState() == LANDING_SWOOPING )
+	{
+		poseBodyAccel = m_poseCargo_Body_Accel;
+		poseBodySway = m_poseCargo_Body_Sway;
+		SetPoseParameter( m_poseBody_Accel, 0 );
+		SetPoseParameter( m_poseBody_Sway, 0 );
+	}
+	else
+	{
+		poseBodyAccel = m_poseBody_Accel;
+		poseBodySway = m_poseBody_Sway;
+		SetPoseParameter( m_poseCargo_Body_Accel, 0 );
+		SetPoseParameter( m_poseCargo_Body_Sway, 0 );
+	}
+
+	// If we're landing, deliberately tuck in the back end
+	if ( GetLandingState() == LANDING_DESCEND || GetLandingState() == LANDING_TOUCHDOWN || 
+		 GetLandingState() == LANDING_UNLOADING || GetLandingState() == LANDING_UNLOADED || IsHovering() )
+	{
+		finspeed = -60;
+	}
+
+	// Apply the acceleration blend to the fins
+	float finAccelBlend = SimpleSplineRemapVal( finspeed, -60, 60, -1, 1 );
+	float curFinAccel = GetPoseParameter( poseBodyAccel );
+	curFinAccel = UTIL_Approach( finAccelBlend, curFinAccel, 0.1f );
+	SetPoseParameter( poseBodyAccel, EdgeLimitPoseParameter( poseBodyAccel, curFinAccel ) );
+
+	// Apply the spin sway to the fins
+	float finSwayBlend = SimpleSplineRemapVal( swayspeed, -60, 60, -1, 1 );
+	float curFinSway = GetPoseParameter( poseBodySway );
+	curFinSway = UTIL_Approach( finSwayBlend, curFinSway, 0.1f );
+	SetPoseParameter( poseBodySway, EdgeLimitPoseParameter( poseBodySway, curFinSway ) );
+
+	if ( bRunFlight )
+	{
+		// Add in our velocity pulse for this frame
+		ApplyAbsVelocityImpulse( vecImpulse );
+	}
+
+	//DevMsg("curFinAccel: %f, curFinSway: %f\n", curFinAccel, curFinSway );
+}
+
+
+//------------------------------------------------------------------------------
+// Deals damage to what's behing carried
+//------------------------------------------------------------------------------
+int CNPC_CombineDropship::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo ) 
+{
+	// FIXME: To make this work for CRATE_STRIDER or CRATE_APC, we need to
+	// add code to the strider + apc to make them not take double-damage from rockets
+	// (owing to the blast hitting the crate + the dropship). See the dropship container
+	// code above to see how to do it.
+	if ( m_hContainer && !m_bInvulnerable )
+	{
+		if ( (inputInfo.GetDamageType() & DMG_AIRBOAT) || (m_iCrateType == CRATE_SOLDIER) )
+		{
+			m_hContainer->TakeDamage( inputInfo );
+		}
+	}
+
+	// don't die
+	return 0; 
+}
+
+//------------------------------------------------------------------------------
+// Updates the facing direction
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateFacingDirection( void )
+{
+	if ( GetEnemy() )
+	{
+		if ( !IsCrashing() && m_flLastSeen + 5 > gpGlobals->curtime )
+		{
+			// If we've seen the target recently, face the target.
+			//Msg( "Facing Target \n" );
+			m_vecDesiredFaceDir = m_vecTargetPosition - GetAbsOrigin();
+		}
+		else
+		{
+			// Remain facing the way you were facing...
+		}
+	}
+	else
+	{
+		// Face our desired position.
+		if ( GetDesiredPosition().DistToSqr( GetAbsOrigin() ) > 1 )
+		{
+			m_vecDesiredFaceDir = GetDesiredPosition() - GetAbsOrigin();
+		}
+		else
+		{
+			GetVectors( &m_vecDesiredFaceDir, NULL, NULL );
+		}
+	}
+	VectorNormalize( m_vecDesiredFaceDir ); 
+}
+
+//------------------------------------------------------------------------------
+// Purpose : 
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InitializeRotorSound( void )
+{
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+
+	CPASAttenuationFilter filter( this );
+	m_pRotorSound = controller.SoundCreate( filter, entindex(), "NPC_CombineDropship.RotorLoop" );
+	m_pNearRotorSound = controller.SoundCreate( filter, entindex(), "NPC_CombineDropship.NearRotorLoop" );
+	m_pRotorOnGroundSound = controller.SoundCreate( filter, entindex(), "NPC_CombineDropship.OnGroundRotorLoop" );
+	m_pDescendingWarningSound = controller.SoundCreate( filter, entindex(), "NPC_CombineDropship.DescendingWarningLoop" );
+	m_pCannonSound = controller.SoundCreate( filter, entindex(), "NPC_CombineDropship.FireLoop"  );
+
+	// NOTE: m_pRotorSound is started up by the base class
+	if ( m_pCannonSound )
+	{
+		controller.Play( m_pCannonSound, 0.0, 100 );
+	}
+
+	if ( m_pDescendingWarningSound )
+	{
+		controller.Play( m_pDescendingWarningSound, 0.0, 100 );
+	}
+
+	if ( m_pRotorOnGroundSound )
+	{
+		controller.Play( m_pRotorOnGroundSound, 0.0, 100 );
+	}
+	
+	if ( m_pNearRotorSound )
+	{
+		controller.Play( m_pNearRotorSound, 0.0, 100 );
+	}
+
+	m_engineThrust = 1.0f;
+
+	BaseClass::InitializeRotorSound();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::StopLoopingSounds()
+{
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+
+	if ( m_pCannonSound )
+	{
+		controller.SoundDestroy( m_pCannonSound );
+		m_pCannonSound = NULL;
+	}
+
+	if ( m_pRotorOnGroundSound )
+	{
+		controller.SoundDestroy( m_pRotorOnGroundSound );
+		m_pRotorOnGroundSound = NULL;
+	}
+
+	if ( m_pDescendingWarningSound )
+	{
+		controller.SoundDestroy( m_pDescendingWarningSound );
+		m_pDescendingWarningSound = NULL;
+	}
+
+	if ( m_pNearRotorSound )
+	{
+		controller.SoundDestroy( m_pNearRotorSound );
+		m_pNearRotorSound = NULL;
+	}
+
+	BaseClass::StopLoopingSounds();
+}
+
+
+//------------------------------------------------------------------------------
+// Updates the rotor wash volume
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateRotorWashVolume( CSoundPatch *pRotorSound, float flVolume, float flDeltaTime )
+{
+	if ( !pRotorSound )
+		return;
+
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+	float flVolDelta = flVolume - controller.SoundGetVolume( pRotorSound );
+	if ( flVolDelta )
+	{
+		// We can change from 0 to 1 in 3 seconds. 
+		// Figure out how many seconds flVolDelta will take.
+		float flRampTime = fabs( flVolDelta ) * flDeltaTime; 
+		controller.SoundChangeVolume( pRotorSound, flVolume, flRampTime );
+	}
+}
+
+
+//------------------------------------------------------------------------------
+// Updates the rotor wash volume
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateRotorWashVolume()
+{
+	float flNearFactor = 0.0f; 
+	CBaseEntity *pPlayer = UTIL_PlayerByIndex( 1 );
+	if (pPlayer)
+	{
+		float flDist = pPlayer->GetAbsOrigin().DistTo( GetAbsOrigin() );
+		flDist = clamp( flDist, DROPSHIP_NEAR_SOUND_MIN_DISTANCE, DROPSHIP_NEAR_SOUND_MAX_DISTANCE );
+		flNearFactor = RemapVal( flDist, DROPSHIP_NEAR_SOUND_MIN_DISTANCE, DROPSHIP_NEAR_SOUND_MAX_DISTANCE, 1.0f, 0.0f );
+	}
+
+	if ( m_pRotorSound )
+	{
+		UpdateRotorWashVolume( m_pRotorSound, m_engineThrust * GetRotorVolume() * (1.0f - flNearFactor), 3.0f );
+	}
+
+	if ( m_pNearRotorSound )
+	{
+		UpdateRotorWashVolume( m_pNearRotorSound, m_engineThrust * GetRotorVolume() * flNearFactor, 3.0f );
+	}
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateRotorSoundPitch( int iPitch )
+{
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+
+	float rotorPitch = 0.2 + m_engineThrust * 0.8;
+	if ( m_pRotorSound )
+	{
+		controller.SoundChangePitch( m_pRotorSound, iPitch + rotorPitch, 0.1 );
+	}
+
+	if ( m_pNearRotorSound )
+	{
+		controller.SoundChangePitch( m_pNearRotorSound, iPitch + rotorPitch, 0.1 );
+	}
+
+	if (m_pRotorOnGroundSound)
+	{
+		controller.SoundChangePitch( m_pRotorOnGroundSound, iPitch + rotorPitch, 0.1 );
+	}
+
+	UpdateRotorWashVolume();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iSoldiers - 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::CalculateSoldierCount( int iSoldiers )
+{
+	if ( m_iCrateType >= 0 ) 
+	{
+		m_soldiersToDrop = clamp( iSoldiers, 0, DROPSHIP_MAX_SOLDIERS );
+	}
+	else
+	{
+		m_soldiersToDrop = 0;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Leave crate being carried
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InputLandLeave( inputdata_t &inputdata )
+{
+	CalculateSoldierCount( inputdata.value.Int() );
+	m_leaveCrate = true;
+	LandCommon();
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Take crate being carried to next point
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InputLandTake( inputdata_t &inputdata )
+{
+	CalculateSoldierCount( inputdata.value.Int() );
+	m_leaveCrate = false;
+	LandCommon();
+}
+
+//------------------------------------------------------------------------------
+// Purpose : 
+// Input   : bHover - If true, means we're landing on a hover point, not the ground
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::LandCommon( bool bHover )
+{
+	// If we don't have a crate, we're not able to land
+	if ( !m_hContainer && !bHover )
+		return;
+
+	//DevMsg( "Landing\n" );
+
+	if( bHover )
+	{
+		SetLandingState( LANDING_HOVER_LEVEL_OUT );
+	}
+	else
+	{
+		SetLandingState( LANDING_LEVEL_OUT );
+	}
+
+	SetLocalAngularVelocity( vec3_angle );
+
+	// Do we have a land target?
+	if ( m_iszLandTarget != NULL_STRING )
+	{
+		CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, m_iszLandTarget );
+		if ( !pTarget )
+		{
+			Warning("npc_combinedropship %s couldn't find land target named %s\n", STRING(GetEntityName()), STRING(m_iszLandTarget) );
+			return;
+		}
+
+		// Start heading to the point
+		m_hLandTarget = pTarget;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputSetLandTarget( inputdata_t &inputdata )
+{
+	m_iszLandTarget = inputdata.value.StringID();
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Drop mine inputs... done this way so generic path_corners can be used
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InputDropMines( inputdata_t &inputdata )
+{
+	m_totalMinesToDrop = inputdata.value.Int();
+	if ( m_totalMinesToDrop >= 1 )	// catch bogus values being passed in
+	{
+		m_bDropMines = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputDropStrider( inputdata_t &inputdata )
+{
+	if ( !m_hContainer || !FClassnameIs( m_hContainer, "npc_strider" ) )
+	{
+		Warning("npc_combinedropship %s was told to drop Strider, but isn't carrying one!\n", STRING(GetEntityName()) );
+		return;
+	}
+
+	QAngle angles = GetAbsAngles();
+
+	angles.x = 0.0;
+	angles.z = 0.0;
+
+	m_hContainer->SetParent(NULL, 0);
+	m_hContainer->SetOwnerEntity(NULL);
+	m_hContainer->SetAbsAngles( angles );
+	m_hContainer->SetAbsVelocity( vec3_origin );
+
+	m_hContainer = NULL;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputDropAPC( inputdata_t &inputdata )
+{
+	if ( !m_hContainer || !FClassnameIs( m_hContainer, "prop_vehicle_apc" ) )
+	{
+		Warning("npc_combinedropship %s was told to drop APC, but isn't carrying one!\n", STRING(GetEntityName()) );
+		return;
+	}
+
+	m_hContainer->SetParent(NULL, 0);
+//	m_hContainer->SetOwnerEntity(NULL);
+
+	Vector vecAbsVelocity = GetAbsVelocity();
+	if ( vecAbsVelocity.z > 0 )
+	{
+		vecAbsVelocity.z = 0.0f;
+	}
+	if ( m_hContainer->GetHealth() > 0 )
+	{
+		vecAbsVelocity = vec3_origin;
+	}
+
+	m_hContainer->SetAbsVelocity( vecAbsVelocity );
+	m_hContainer->SetMoveType( (MoveType_t)m_iContainerMoveType );
+
+	// If the container has a physics object, remove it's shadow
+	IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+	if ( pPhysicsObject )
+	{
+		pPhysicsObject->RemoveShadowController();
+	}
+
+	UTIL_SetSize( this, DROPSHIP_BBOX_MIN, DROPSHIP_BBOX_MAX );
+
+	m_hContainer = NULL;
+	m_OnFinishedDropoff.FireOutput( this, this );
+	SetLandingState( LANDING_NO );
+	m_hLandTarget = NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Drop the soldier container
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::DropSoldierContainer( )
+{
+	m_hContainer->SetParent(NULL, 0);
+//	m_hContainer->SetOwnerEntity(NULL);
+
+	Vector vecAbsVelocity = GetAbsVelocity();
+	if ( vecAbsVelocity.z > 0 )
+	{
+		vecAbsVelocity.z = 0.0f;
+	}
+
+	m_hContainer->SetAbsVelocity( vecAbsVelocity );
+	m_hContainer->SetMoveType( MOVETYPE_VPHYSICS );
+
+	// If we have a troop in the process of exiting, kill him.
+	// We do this to avoid having to solve the AI problems resulting from it.
+	if ( m_hLastTroopToLeave )
+	{
+		CTakeDamageInfo dmgInfo( this, this, vec3_origin, m_hContainer->GetAbsOrigin(), m_hLastTroopToLeave->GetMaxHealth(), DMG_GENERIC );
+		m_hLastTroopToLeave->TakeDamage( dmgInfo );
+	}
+
+	// If the container has a physics object, remove it's shadow
+	IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+	if ( pPhysicsObject )
+	{
+		pPhysicsObject->RemoveShadowController();
+		pPhysicsObject->SetVelocity( &vecAbsVelocity, &vec3_origin );
+	}
+
+	UTIL_SetSize( this, DROPSHIP_BBOX_MIN, DROPSHIP_BBOX_MAX );
+
+	m_hContainer = NULL;
+	SetLandingState( LANDING_NO );
+	m_hLandTarget = NULL;
+
+	if ( m_bHasDroppedOff )
+	{
+		m_OnContainerShotDownAfterDropoff.FireOutput( this, this );
+	}
+	else
+	{
+		int iTroopsNotUnloaded = (m_soldiersToDrop - m_iCurrentTroopExiting);
+		if ( g_debug_dropship.GetInt() )
+		{
+			Msg("Dropship died, troops not unloaded: %d\n", iTroopsNotUnloaded );
+		}
+
+		m_OnContainerShotDownBeforeDropoff.Set( iTroopsNotUnloaded, this, this );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Pick up a specified object
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputPickup( inputdata_t &inputdata )
+{
+	// Can't pickup if we're already carrying something
+	if ( m_hContainer )
+	{
+		Warning("npc_combinedropship %s was told to pickup, but is already carrying something.\n", STRING(GetEntityName()) );
+		return;
+	}
+
+	string_t iszTargetName = inputdata.value.StringID();
+	if ( iszTargetName == NULL_STRING )
+	{
+		Warning("npc_combinedropship %s tried to pickup with no specified pickup target.\n", STRING(GetEntityName()) );
+		return;
+	}
+	CBaseEntity *pTarget = gEntList.FindEntityByName( NULL, iszTargetName );
+	if ( !pTarget )
+	{
+		Warning("npc_combinedropship %s couldn't find pickup target named %s\n", STRING(GetEntityName()), STRING(iszTargetName) );
+		return;
+	}
+
+	// Start heading to the point
+	m_hPickupTarget = pTarget;
+
+	m_bHasDroppedOff = false;
+
+	// Disable collisions to my target
+	m_hPickupTarget->SetOwnerEntity(this);
+	if ( m_NPCState == NPC_STATE_IDLE )
+	{
+		SetState( NPC_STATE_ALERT );
+	}
+	SetLandingState( LANDING_SWOOPING );
+	m_flLandingSpeed = GetAbsVelocity().Length();
+
+	UpdatePickupNavigation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the range of the container's gun
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputSetGunRange( inputdata_t &inputdata )
+{
+	m_flGunRange = inputdata.value.Float();
+}
+
+
+//------------------------------------------------------------------------------
+// Set the landing state
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::SetLandingState( LandingState_t landingState )
+{
+	if ( landingState == m_iLandState )
+		return;
+
+	if ( m_pDescendingWarningSound )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		if ( ( landingState == LANDING_DESCEND ) || ( landingState == LANDING_TOUCHDOWN ) || ( landingState == LANDING_UNLOADING ) || ( landingState == LANDING_UNLOADED ) || ( landingState == LANDING_HOVER_DESCEND ) )
+		{
+			controller.SoundChangeVolume( m_pDescendingWarningSound, m_bSuppressSound ? 0.0f : 1.0f, 0.3f );
+		}
+		else
+		{
+			controller.SoundChangeVolume( m_pDescendingWarningSound, 0.0f, 0.0f );
+		}
+	}
+	
+	m_iLandState = landingState;
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+bool CNPC_CombineDropship::IsHovering()
+{
+	bool bIsHovering = false;
+
+	if( GetLandingState() > LANDING_START_HOVER && GetLandingState() < LANDING_END_HOVER )
+	{
+		bIsHovering = true;
+	}
+
+	return bIsHovering;
+}
+
+//------------------------------------------------------------------------------
+// Update the ground rotorwash volume
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateGroundRotorWashSound( float flAltitude )
+{
+	float flVolume = RemapValClamped( flAltitude, DROPSHIP_GROUND_WASH_MIN_ALTITUDE, DROPSHIP_GROUND_WASH_MAX_ALTITUDE, 1.0f, 0.0f );
+	UpdateRotorWashVolume( m_pRotorOnGroundSound, flVolume * GetRotorVolume(), 0.5f );
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose : 
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::PrescheduleThink( void )
+{	
+	BaseClass::PrescheduleThink();
+
+	// "npc_kill" destroys our container
+	if (m_debugOverlays & OVERLAY_NPC_KILL_BIT)
+	{
+		if ( m_hContainer )
+		{
+			CTakeDamageInfo dmgInfo( this, this, vec3_origin, vec3_origin, 1000, DMG_BLAST );
+			m_hContainer->TakeDamage( dmgInfo );
+		}
+	}
+
+	// Update the ground rotorwash volume
+	float flAltitude = GetAltitude();
+	UpdateGroundRotorWashSound( flAltitude );
+
+	// keep track of think time deltas for burn calc below
+	float dt = gpGlobals->curtime - m_flLastTime;
+	m_flLastTime = gpGlobals->curtime;
+
+	switch( GetLandingState() )
+	{
+	case LANDING_NO:
+		{
+			if ( IsActivityFinished() && (GetActivity() != ACT_DROPSHIP_FLY_IDLE_EXAGG && GetActivity() != ACT_DROPSHIP_FLY_IDLE_CARGO) )
+			{
+				if ( m_hContainer )
+				{
+					SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_CARGO );
+				}
+				else
+				{
+					SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_EXAGG );
+				}
+			}
+
+			DoRotorWash();
+		}
+		break;
+
+	case LANDING_LEVEL_OUT:
+	case LANDING_HOVER_LEVEL_OUT:
+		{
+			// Approach the drop point
+			Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
+			float flDistance = vecToTarget.Length();
+
+			// Are we there yet?
+			float flSpeed = GetAbsVelocity().Length();
+			if ( flDistance < 70 && flSpeed < 100 )
+			{
+				m_flLandingSpeed = flSpeed;
+
+				if( IsHovering() )
+				{
+					SetLandingState( LANDING_HOVER_DESCEND );
+				}
+				else
+				{
+					SetLandingState( LANDING_DESCEND );
+				}
+
+				// save off current angles so we can work them out over time
+				QAngle angles = GetLocalAngles();
+				m_existPitch = angles.x;
+				m_existRoll = angles.z;
+			}
+
+			DoRotorWash();
+		}
+		break;
+
+	case LANDING_DESCEND:
+	case LANDING_HOVER_DESCEND:
+		{
+			/*
+			if ( IsActivityFinished() && GetActivity() != ACT_DROPSHIP_DESCEND_IDLE )
+			{
+				SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
+			}
+			*/
+
+			if( IsHovering() && m_hLandTarget != NULL )
+			{
+				// We're trying to hover above an arbitrary point, not above the ground. 
+				// Recompute flAltitude to indicate the vertical distance from the land 
+				// target so that touchdown is correctly detected.
+				flAltitude = GetAbsOrigin().z - m_hLandTarget->GetAbsOrigin().z;
+			}
+
+			// Orient myself to the desired direction
+			bool bStillOrienting = false;
+			Vector targetDir;
+			if ( m_hLandTarget )
+			{
+				// We've got a land target, so match it's orientation
+				AngleVectors( m_hLandTarget->GetAbsAngles(), &targetDir );
+			}
+			else
+			{
+				// No land target. 
+				targetDir = GetDesiredPosition() - GetAbsOrigin();
+			}
+
+			// Don't unload until we're facing the way the dropoff point specifies
+			float flTargetYaw = UTIL_VecToYaw( targetDir );
+			float flDeltaYaw = UTIL_AngleDiff( flTargetYaw, GetAbsAngles().y );
+			if ( fabs(flDeltaYaw) > 5 )
+			{
+				bStillOrienting = true;
+			}
+
+			// Ensure we land on the drop point. Stop dropping if we're still turning.
+			Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
+			float flDistance = vecToTarget.Length();
+			float flRampedSpeed = m_flLandingSpeed * (flDistance / 70);
+			Vector vecVelocity = (flRampedSpeed / flDistance) * vecToTarget;
+			
+#define MAX_LAND_VEL	-300.0f
+#define MIN_LAND_VEL	-75.0f
+#define ALTITUDE_CAP	512.0f
+
+			float flFactor = MIN( 1.0,  flAltitude / ALTITUDE_CAP );
+			float flDescendVelocity = MIN( -75, MAX_LAND_VEL * flFactor );
+
+			vecVelocity.z = flDescendVelocity;
+
+			SetAbsVelocity( vecVelocity );
+
+			if ( flAltitude < 72 )
+			{
+				QAngle angles = GetLocalAngles();
+
+				// Level out quickly.
+				angles.x = UTIL_Approach( 0.0, angles.x, 0.2 );
+				angles.z = UTIL_Approach( 0.0, angles.z, 0.2 );
+
+				SetLocalAngles( angles );
+			}
+			else
+			{
+				// randomly move as if buffeted by ground effects
+				// gently flatten ship from starting pitch/yaw
+				m_existPitch = UTIL_Approach( 0.0, m_existPitch, 1 );
+				m_existRoll = UTIL_Approach( 0.0, m_existRoll, 1 );
+
+				QAngle angles = GetLocalAngles();
+				angles.x = m_existPitch + ( sin( gpGlobals->curtime * 3.5f ) * DROPSHIP_MAX_LAND_TILT );
+				angles.z = m_existRoll + ( sin( gpGlobals->curtime * 3.75f ) * DROPSHIP_MAX_LAND_TILT );
+				SetLocalAngles( angles );
+			}
+
+			DoRotorWash();
+
+			// place danger sounds 1 foot above ground to get troops to scatter if they are below dropship
+			Vector vecBottom = GetAbsOrigin();
+			vecBottom.z += WorldAlignMins().z;
+			Vector vecSpot = vecBottom + Vector(0, 0, -1) * (flAltitude - 12 );
+			CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, 400, 0.1, this, 0 );
+			CSoundEnt::InsertSound( SOUND_PHYSICS_DANGER, vecSpot, 400, 0.1, this, 1 );
+//			NDebugOverlay::Cross3D( vecSpot, -Vector(4,4,4), Vector(4,4,4), 255, 0, 255, false, 10.0f );
+
+			// now check to see if player is below us, if so, cause heat damage to them (i.e. get them to move)
+			trace_t tr;
+			Vector vecBBoxMin = CRATE_BBOX_MIN;		// use flat box for check
+			vecBBoxMin.z = -5;
+			Vector vecBBoxMax = CRATE_BBOX_MAX;
+			vecBBoxMax.z = 5;
+			Vector pEndPoint = vecBottom + Vector(0, 0, -1) * ( flAltitude - 12 );
+			AI_TraceHull( vecBottom, pEndPoint, vecBBoxMin, vecBBoxMax, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
+
+			if ( tr.fraction < 1.0f )
+			{
+				// Damage anything that's blocking me
+				if ( tr.m_pEnt && tr.m_pEnt->m_takedamage != DAMAGE_NO )
+				{
+					CTakeDamageInfo info( this, this, 20 * dt, DMG_BURN );
+					tr.m_pEnt->TakeDamage( info );
+				}
+			}
+
+			if ( !bStillOrienting && ((flAltitude <= 0.5f) || (m_iCrateType == CRATE_APC)) )
+			{
+				if( IsHovering() )
+				{
+					SetAbsVelocity( vec3_origin );
+					SetLandingState( LANDING_HOVER_TOUCHDOWN );
+				}
+				else
+				{
+					SetLandingState( LANDING_TOUCHDOWN );
+				}
+
+				// upon landing, make sure ship is flat
+				QAngle angles = GetLocalAngles();
+				angles.x = 0;
+				angles.z = 0;
+				SetLocalAngles( angles );
+
+				// TODO: Release cargo anim
+				//SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
+				return;
+			}
+		}
+		break;
+
+	case LANDING_TOUCHDOWN:
+	case LANDING_HOVER_TOUCHDOWN:
+		{
+			/*
+			if ( IsActivityFinished() && ( GetActivity() != ACT_DROPSHIP_DESCEND_IDLE ) )
+			{
+				SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
+			}
+			*/
+
+			// Wait here if we're supposed to wait for the dropoff input
+			if ( m_bWaitForDropoffInput )
+				return;
+
+			// Wait here till designer tells us to get moving again.
+			if ( IsHovering() )
+				return;
+
+			SetLandingState( LANDING_UNLOADING );
+
+			// If we're dropping off troops, we'll wait for them to be done. 
+			// Otherwise, just pause on the ground for a few seconds and then leave.
+			if ( m_soldiersToDrop && m_hContainer)
+			{
+				m_flTimeTakeOff = 0;
+				m_flNextTroopSpawnAttempt = 0;
+
+				// Open our container
+				m_hContainer->SetSequence( m_hContainer->LookupSequence("open_idle") );
+
+				// Start unloading troops
+				m_iCurrentTroopExiting = 0;
+				SpawnTroop();
+			}
+			else
+			{
+				float flHoverTime = ( m_iCrateType >= 0 ) ? DROPSHIP_LANDING_HOVER_TIME : 0.5f;
+				m_flTimeTakeOff = gpGlobals->curtime + flHoverTime;
+			}
+		}
+		break;
+
+	case LANDING_UNLOADING:
+		{
+			// If we've got no specified takeoff time, we're still waiting for troops to exit. Idle.
+			if ( !m_flTimeTakeOff )
+			{
+				float idleVolume = 0.2f;
+				m_engineThrust = UTIL_Approach( idleVolume, m_engineThrust, 0.04f );
+				if ( m_engineThrust > idleVolume ) 
+				{
+					// Make sure we're kicking up dust/water as long as engine thrust is up
+					DoRotorWash();				
+				}
+
+				// If we've lost the last troop who was leaving, he probably got killed during dustoff.
+				if ( !m_hLastTroopToLeave || !m_hLastTroopToLeave->IsAlive() )
+				{
+					// If we still have troops onboard, spawn the next one
+					if ( m_iCurrentTroopExiting < m_soldiersToDrop )
+					{
+						SpawnTroop();
+					}
+					else
+					{
+						// We're out of troops, time to leave
+						m_flTimeTakeOff = gpGlobals->curtime + 0.5;
+					}
+				}
+			}
+			else
+			{
+				if( gpGlobals->curtime > m_flTimeTakeOff )
+				{
+					SetLandingState( LANDING_LIFTOFF );
+					SetActivity( (Activity)ACT_DROPSHIP_LIFTOFF );
+					m_engineThrust = 1.0f;			// ensure max volume once we're airborne
+					if ( m_bIsFiring )
+					{
+						StopCannon();				// kill cannon sounds if they are on
+					}
+
+					// detach container from ship
+					if ( m_hContainer && m_leaveCrate )
+					{
+						m_hContainer->SetParent(NULL);
+						m_hContainer->SetMoveType( (MoveType_t)m_iContainerMoveType );
+
+						Vector vecAbsVelocity( 0, 0, GetAbsVelocity().z );
+						if ( vecAbsVelocity.z > 0 )
+						{
+							vecAbsVelocity.z = 0.0f;
+						}
+
+						m_hContainer->SetAbsVelocity( vecAbsVelocity );
+
+						// If the container has a physics object, remove it's shadow
+						IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+						if ( pPhysicsObject )
+						{
+							pPhysicsObject->RemoveShadowController();
+							pPhysicsObject->SetVelocity( &vecAbsVelocity, &vec3_origin );
+						}
+
+						m_hContainer = NULL;
+						UTIL_SetSize( this, DROPSHIP_BBOX_MIN, DROPSHIP_BBOX_MAX );
+					}
+				}
+				else if ( (m_flTimeTakeOff - gpGlobals->curtime) < 0.5f )
+				{
+					// Manage engine wash and volume
+					m_engineThrust = UTIL_Approach( 1.0f, m_engineThrust, 0.1f );
+					DoRotorWash();
+				}
+			}
+		}
+		break;
+
+	case LANDING_LIFTOFF:
+		{
+			// Once we're off the ground, start flying again
+			if ( flAltitude > 120 )		
+			{
+				SetLandingState( LANDING_NO );
+				m_hLandTarget = NULL;
+				m_bHasDroppedOff = true;
+				m_OnFinishedDropoff.FireOutput( this, this );
+			}
+
+			if ( m_hContainer )
+			{
+				m_hContainer->SetSequence( m_hContainer->LookupSequence("close_idle") );
+			}
+		}
+		break;
+
+	case LANDING_SWOOPING:
+		{
+			// Did we lose our pickup target?
+			if ( !m_hPickupTarget )
+			{
+				SetLandingState( LANDING_NO );
+			}
+			else
+			{
+				// Decrease altitude and speed to hit the target point.
+				Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
+				float flDistance = vecToTarget.Length();
+
+				// Start cheating when we get near it
+				if ( flDistance < 50 )
+				{
+					/*
+					if ( flDistance > 10 )
+					{
+						// Cheat and ensure we touch the target
+						float flSpeed = GetAbsVelocity().Length();
+						Vector vecVelocity = vecToTarget;
+						VectorNormalize( vecVelocity );
+						SetAbsVelocity( vecVelocity * min(flSpeed,flDistance) );
+					}
+					else
+					*/
+					{
+						// Grab the target
+						m_hContainer = m_hPickupTarget;
+						m_hPickupTarget = NULL;
+						m_iContainerMoveType = m_hContainer->GetMoveType();
+						if ( m_bInvulnerable && m_hContainer )
+						{
+							m_hContainer->m_takedamage = DAMAGE_NO;
+						}
+
+						// If the container has a physics object, move it to shadow
+						IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
+						if ( pPhysicsObject )
+						{
+							pPhysicsObject->EnableMotion( true );
+							pPhysicsObject->SetShadow( 1e4, 1e4, false, false );
+							pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
+						}
+
+						m_hContainer->SetParent(this, 0);
+						m_hContainer->SetMoveType( MOVETYPE_PUSH );
+						m_hContainer->SetGroundEntity( NULL );
+
+						m_OnFinishedPickup.FireOutput( this, this );
+						SetLandingState( LANDING_NO );
+					}
+				}
+			}
+
+			DoRotorWash();
+		}
+		break;
+	}
+
+	if ( !(CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
+	{
+		DoCombatStuff();
+	}
+
+	if ( GetActivity() != GetIdealActivity() )
+	{
+		//DevMsg( "setactivity" );
+		SetActivity( GetIdealActivity() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+#define DROPSHIP_WASH_ALTITUDE 1024.0
+
+void CNPC_CombineDropship::DoRotorWash( void )
+{
+	Vector	vecForward;
+	GetVectors( &vecForward, NULL, NULL );
+
+	Vector vecRotorHub = GetAbsOrigin() + vecForward * -64;
+
+	DrawRotorWash( DROPSHIP_WASH_ALTITUDE, vecRotorHub );
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose : Spawn the next NPC in our template list
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::SpawnTroop( void )
+{
+	if ( !m_hContainer )
+	{
+		// We're done, take off.
+		m_flTimeTakeOff = gpGlobals->curtime + 0.5;
+		return;
+	}
+
+	// Are we fully unloaded? If so, take off. Otherwise, tell the next troop to exit.
+	if ( m_iCurrentTroopExiting >= m_soldiersToDrop || m_sNPCTemplateData[m_iCurrentTroopExiting] == NULL_STRING )
+	{
+		// We're done, take off.
+		m_flTimeTakeOff = gpGlobals->curtime + 0.5;
+		return;
+	}
+
+	m_hLastTroopToLeave = NULL;
+
+	// Not time to try again yet?
+	if ( m_flNextTroopSpawnAttempt > gpGlobals->curtime )
+		return;
+
+	// HACK: This is a nasty piece of work. We want to make sure the deploy end is clear, and has enough
+	// room with our deploying NPC, but we don't want to create the NPC unless it's clear, and we don't
+	// know how much room he needs without spawning him. 
+	// So, because we know that we only ever spawn combine soldiers at the moment, we'll just use their hull.
+	// HACK: Add some bloat because the endpoint isn't perfectly aligned with NPC end origin
+	Vector vecNPCMins = NAI_Hull::Mins( HULL_HUMAN ) - Vector(4,4,4);
+	Vector vecNPCMaxs = NAI_Hull::Maxs( HULL_HUMAN ) + Vector(4,4,4);
+
+	// Scare NPCs away from our deploy endpoint to keep them away
+	Vector vecDeployEndPoint;
+	QAngle vecDeployEndAngles;
+	m_hContainer->GetAttachment( m_iAttachmentTroopDeploy, vecDeployEndPoint, vecDeployEndAngles );
+	vecDeployEndPoint = GetDropoffFinishPosition( vecDeployEndPoint, NULL, vecNPCMins, vecNPCMaxs );
+	CSoundEnt::InsertSound( SOUND_DANGER, vecDeployEndPoint, 120.0f, 2.0f, this );
+
+	// Make sure there are no NPCs on the spot
+	trace_t tr;
+	CTraceFilterOnlyNPCsAndPlayer filter( this, COLLISION_GROUP_NONE );
+	AI_TraceHull( vecDeployEndPoint, vecDeployEndPoint, vecNPCMins, vecNPCMaxs, MASK_SOLID, &filter, &tr );
+	if ( tr.m_pEnt )
+	{
+		if ( g_debug_dropship.GetInt() == 2 )
+		{
+			NDebugOverlay::Box( vecDeployEndPoint, vecNPCMins, vecNPCMaxs, 255,0,0, 64, 0.5 );
+		}
+
+		m_flNextTroopSpawnAttempt = gpGlobals->curtime + 1;
+		return;
+	}
+
+	if ( g_debug_dropship.GetInt() == 2 )
+	{
+		NDebugOverlay::Box( vecDeployEndPoint, vecNPCMins, vecNPCMaxs, 0,255,0, 64, 0.5 );
+	}
+
+	// Get the spawn point inside the container
+	Vector vecSpawnOrigin;
+	QAngle vecSpawnAngles;
+	m_hContainer->GetAttachment( m_iAttachmentDeployStart, vecSpawnOrigin, vecSpawnAngles );
+
+	// Spawn the templated NPC
+	CBaseEntity *pEntity = NULL;
+	MapEntity_ParseEntity( pEntity, STRING(m_sNPCTemplateData[m_iCurrentTroopExiting]), NULL );
+
+	// Increment troop count
+	m_iCurrentTroopExiting++;
+
+	if ( !pEntity )
+	{
+		Warning("Dropship could not create template NPC\n" );
+		return;
+	}
+	CAI_BaseNPC	*pNPC = pEntity->MyNPCPointer();
+	Assert( pNPC );
+
+	// Spawn an entity blocker.
+	CBaseEntity *pBlocker = CEntityBlocker::Create( vecDeployEndPoint, vecNPCMins, vecNPCMaxs, pNPC, true );
+	g_EventQueue.AddEvent( pBlocker, "Kill", 2.5, this, this );
+	if ( g_debug_dropship.GetInt() == 2 )
+	{
+		NDebugOverlay::Box( vecDeployEndPoint, vecNPCMins, vecNPCMaxs, 255, 255, 255, 64, 2.5 );
+	}
+
+	// Ensure our NPCs are standing upright
+	vecSpawnAngles[PITCH] = vecSpawnAngles[ROLL] = 0;
+
+	// Move it to the container spawnpoint
+	pNPC->SetAbsOrigin( vecSpawnOrigin );
+	pNPC->SetAbsAngles( vecSpawnAngles );
+	DispatchSpawn( pNPC );
+	pNPC->m_NPCState = NPC_STATE_IDLE;
+	pNPC->Activate();
+
+	// Spawn a scripted sequence entity to make the NPC run out of the dropship
+	CAI_ScriptedSequence *pSequence = (CAI_ScriptedSequence*)CreateEntityByName( "scripted_sequence" );
+	pSequence->KeyValue( "m_iszEntity", STRING(pNPC->GetEntityName()) );
+	pSequence->KeyValue( "m_iszPlay", "Dropship_Deploy" );
+	pSequence->KeyValue( "m_fMoveTo", "4" );	// CINE_MOVETO_TELEPORT
+	pSequence->KeyValue( "OnEndSequence", UTIL_VarArgs("%s,NPCFinishDustoff,%s,0,-1", STRING(GetEntityName()), STRING(pNPC->GetEntityName())) );
+	pSequence->SetAbsOrigin( vecSpawnOrigin );
+	pSequence->SetAbsAngles( vecSpawnAngles );
+	pSequence->AddSpawnFlags( SF_SCRIPT_NOINTERRUPT | SF_SCRIPT_HIGH_PRIORITY | SF_SCRIPT_OVERRIDESTATE );
+	pSequence->Spawn();
+	pSequence->Activate();
+	variant_t emptyVariant;
+	pSequence->AcceptInput( "BeginSequence", this, this, emptyVariant, 0 );
+
+	m_hLastTroopToLeave = pNPC;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a safe position above/below the specified origin for the NPC to finish it's dropoff on
+// Input  : vecOrigin - 
+//-----------------------------------------------------------------------------
+Vector CNPC_CombineDropship::GetDropoffFinishPosition( Vector vecOrigin, CAI_BaseNPC *pNPC, Vector vecMins, Vector vecMaxs )
+{
+	// Use the NPC's if they're specified
+	if ( pNPC )
+	{
+		vecMins = NAI_Hull::Mins( pNPC->GetHullType() );
+		vecMaxs = NAI_Hull::Maxs( pNPC->GetHullType() );
+	}
+
+	trace_t tr;
+	AI_TraceHull( vecOrigin + Vector(0,0,32), vecOrigin, vecMins, vecMaxs, MASK_SOLID, pNPC, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction < 1.0 )
+	{
+		if ( g_debug_dropship.GetInt() == 1 )
+		{
+			NDebugOverlay::Box( vecOrigin, vecMins, vecMaxs, 255,0,0, 8, 4.0 );
+		}
+
+		// Try and find the ground
+		AI_TraceHull( vecOrigin + Vector(0,0,32), vecOrigin, vecMins, vecMaxs, MASK_SOLID, pNPC, COLLISION_GROUP_NONE, &tr );
+		if ( !tr.startsolid )
+			return (tr.endpos + Vector(0,0,1));
+	}
+	else if ( g_debug_dropship.GetInt() == 1 )
+	{
+		NDebugOverlay::Box( vecOrigin, vecMins, vecMaxs, 0,255,0, 8, 4.0 );
+	}
+
+	return vecOrigin;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A troop we dropped of has now finished the scripted sequence
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputNPCFinishDustoff( inputdata_t &inputdata )
+{
+	CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, inputdata.value.StringID(), NULL, inputdata.pActivator, inputdata.pCaller );
+	if ( !pEnt )
+		return;
+
+	CAI_BaseNPC *pNPC = pEnt->MyNPCPointer();
+	Assert( pNPC );
+
+	Vector vecOrigin = GetDropoffFinishPosition( pNPC->GetAbsOrigin(), pNPC, vec3_origin, vec3_origin );
+	pNPC->SetAbsOrigin( vecOrigin );
+
+	// Do we have a dustoff point?
+	CBaseEntity *pDustoff = NULL;
+	if ( m_sDustoffPoints[m_iCurrentTroopExiting-1] != NULL_STRING )
+	{
+		pDustoff = gEntList.FindEntityByName( NULL, m_sDustoffPoints[m_iCurrentTroopExiting-1] );
+		if ( !pDustoff )
+		{
+			Warning("npc_combinedropship %s couldn't find dustoff target named %s\n", STRING(GetEntityName()), STRING(m_sDustoffPoints[m_iCurrentTroopExiting-1]) );
+		}
+	}
+
+	if ( !pDustoff )
+	{
+		// Make a move away sound to scare the combine away from this point
+		CSoundEnt::InsertSound( SOUND_MOVE_AWAY | SOUND_CONTEXT_COMBINE_ONLY, pNPC->GetAbsOrigin(), 128, 0.1 );
+	}
+	else
+	{
+		if ( g_debug_dropship.GetInt() == 1 )
+		{
+			NDebugOverlay::Box( pDustoff->GetAbsOrigin(), -Vector(10,10,10), Vector(10,10,10), 0,255,0, 8, 5.0 );
+		}
+
+		// Tell the NPC to move to the dustoff position
+		pNPC->SetState( NPC_STATE_ALERT );
+		pNPC->ScheduledMoveToGoalEntity( SCHED_DROPSHIP_DUSTOFF, pDustoff, ACT_RUN );
+		pNPC->GetNavigator()->SetArrivalDirection( pDustoff->GetAbsAngles() );
+
+		// Make sure they ignore a bunch of conditions
+		static int g_Conditions[] = 
+		{
+			COND_CAN_MELEE_ATTACK1,
+			COND_CAN_MELEE_ATTACK2,
+			COND_CAN_RANGE_ATTACK1,
+			COND_CAN_RANGE_ATTACK2,
+			COND_ENEMY_DEAD,
+			COND_HEAR_BULLET_IMPACT,
+			COND_HEAR_COMBAT,
+			COND_HEAR_DANGER,
+			COND_NEW_ENEMY,
+			COND_PROVOKED,
+			COND_SEE_ENEMY,
+			COND_SEE_FEAR,
+			COND_SMELL,
+			COND_LIGHT_DAMAGE,
+			COND_HEAVY_DAMAGE,
+			COND_PHYSICS_DAMAGE,
+			COND_REPEATED_DAMAGE,
+		};
+		pNPC->SetIgnoreConditions( g_Conditions, ARRAYSIZE(g_Conditions) );
+	}
+
+	// Unload the next troop
+	SpawnTroop();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tells the dropship to stop waiting and dustoff
+// Input  : &inputdata - 
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::InputStopWaitingForDropoff( inputdata_t &inputdata )
+{
+	m_bWaitForDropoffInput = false;
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InputHover( inputdata_t &inputdata )
+{
+	m_iszLandTarget = inputdata.value.StringID();
+	LandCommon( true );
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::InputFlyToPathTrack( inputdata_t &inputdata )
+{
+	if( IsHovering() )
+	{
+		SetLandingState( LANDING_NO );
+		m_hLandTarget = NULL;
+	}
+
+	CAI_TrackPather::InputFlyToPathTrack( inputdata );
+}
+
+//------------------------------------------------------------------------------
+// Purpose : 
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+float CNPC_CombineDropship::GetAltitude( void )
+{
+	trace_t tr;
+	Vector vecBottom = GetAbsOrigin();
+
+	// Uneven terrain causes us problems, so trace our box down
+	AI_TraceEntity( this, vecBottom, vecBottom - Vector(0,0,4096), MASK_SOLID_BRUSHONLY, &tr );
+
+	float flAltitude = ( 4096 * tr.fraction );
+	//DevMsg(" Altitude: %.3f\n", flAltitude );
+	return flAltitude;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Drop rollermine from dropship
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::DropMine( void )
+{
+	NPC_Rollermine_DropFromPoint( GetAbsOrigin(), this, STRING(m_sRollermineTemplateData) );
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Fly towards our pickup target
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdatePickupNavigation( void )
+{
+	// Try and touch the top of the object
+	Vector vecPickup = m_hPickupTarget->WorldSpaceCenter();
+	vecPickup.z += (m_hPickupTarget->CollisionProp()->OBBSize().z * 0.5);
+	SetDesiredPosition( vecPickup );
+
+	//NDebugOverlay::Cross3D( GetDesiredPosition(), -Vector(32,32,32), Vector(32,32,32), 0, 255, 255, true, 0.1f );
+}
+
+//------------------------------------------------------------------------------
+// Purpose : Fly towards our land target
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateLandTargetNavigation( void )
+{
+	Vector vecPickup = m_hLandTarget->WorldSpaceCenter();
+	vecPickup.z += 256;
+	SetDesiredPosition( vecPickup );
+
+	//NDebugOverlay::Cross3D( GetDesiredPosition(), -Vector(32,32,32), Vector(32,32,32), 0, 255, 255, true, 0.1f );
+}
+
+//------------------------------------------------------------------------------
+// Purpose :
+// Input   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::Hunt( void )
+{
+	// If we have a pickup target, fly to it
+	if ( m_hPickupTarget )
+	{
+		UpdatePickupNavigation();
+	}
+	else if ( m_hLandTarget )
+	{
+		UpdateLandTargetNavigation();
+	}
+	else if ( GetLandingState() == LANDING_NO )
+	{
+		UpdateTrackNavigation();
+	}
+
+	// don't face player ever, only face nav points
+	Vector desiredDir = GetDesiredPosition() - GetAbsOrigin();
+	VectorNormalize( desiredDir ); 
+	// Face our desired position.
+	m_vecDesiredFaceDir = desiredDir;
+
+	if ( GetLandingState() == LANDING_DESCEND || GetLandingState() == LANDING_LEVEL_OUT || IsHovering() )
+	{
+		if ( m_hLandTarget )
+		{
+			// We've got a land target, so match it's orientation
+			AngleVectors( m_hLandTarget->GetAbsAngles(), &m_vecDesiredFaceDir );
+		}
+		else
+		{
+			// No land target. 
+			m_vecDesiredFaceDir = GetDesiredPosition() - GetAbsOrigin();
+		}
+	}
+
+	UpdateEnemy();
+	Flight();
+
+	UpdatePlayerDopplerShift( );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::GatherEnemyConditions( CBaseEntity *pEnemy )
+{
+	BaseClass::GatherEnemyConditions(pEnemy);
+
+	// If we can't see the enemy for a few seconds, consider him unreachable
+	if ( !HasCondition(COND_SEE_ENEMY) )
+	{
+		if ( gpGlobals->curtime - GetEnemyLastTimeSeen() >= 3.0f )
+		{
+			MarkEnemyAsEluded();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: do all of the stuff related to having an enemy, attacking, etc.
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::DoCombatStuff( void )
+{
+	// Handle mines
+	if ( m_bDropMines )
+	{
+		switch( m_iDropState )
+		{
+		case DROP_IDLE:
+			{
+				m_iMineCount = m_totalMinesToDrop - 1;
+
+				DropMine();
+				// setup next individual drop time
+				m_flDropDelay = gpGlobals->curtime + DROPSHIP_TIME_BETWEEN_MINES;
+				// get ready to drop next mine, unless we're only supposed to drop 1
+				if ( m_iMineCount )
+				{
+					m_iDropState = DROP_NEXT;
+				}
+				else
+				{
+					m_bDropMines = false;		// no more...
+				}
+				break;
+			}
+		case DROP_NEXT:
+			{
+				if ( gpGlobals->curtime > m_flDropDelay )		// time to drop next mine?
+				{
+					DropMine();
+					m_flDropDelay = gpGlobals->curtime + DROPSHIP_TIME_BETWEEN_MINES;
+
+					m_iMineCount--;
+					if ( !m_iMineCount )
+					{
+						m_iDropState = DROP_IDLE;
+						m_bDropMines = false;		// reset flag
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	// Handle guns
+	bool bStopGun = true;
+	if ( GetEnemy() )
+	{
+		bStopGun = !FireCannonRound();
+	}
+
+	if ( bStopGun && m_bIsFiring )
+	{
+		StopCannon();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the container's gun to face the enemy. 
+// Input  : &vecMuzzle - The gun's muzzle/firing point
+//			&vecAimDir - The gun's current aim direction
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::UpdateContainerGunFacing( Vector &vecMuzzle, Vector &vecToTarget, Vector &vecAimDir, float *flTargetRange )
+{
+	Assert( m_hContainer );
+
+	// Get the desired aim vector
+	vecToTarget = GetEnemy()->WorldSpaceCenter( );
+
+	Vector vecBarrelPos, vecWorldBarrelPos;
+	QAngle worldBarrelAngle, vecAngles;
+	matrix3x4_t matRefToWorld;
+	m_hContainer->GetAttachment( m_iMuzzleAttachment, vecMuzzle, vecAngles );
+	vecWorldBarrelPos = vecMuzzle;
+	worldBarrelAngle = vecAngles;
+	m_hContainer->GetAttachment( m_iMachineGunRefAttachment, matRefToWorld );
+	VectorITransform( vecWorldBarrelPos, matRefToWorld, vecBarrelPos );
+
+	EntityMatrix parentMatrix;
+	parentMatrix.InitFromEntity( m_hContainer, m_iMachineGunBaseAttachment );
+	Vector target = parentMatrix.WorldToLocal( vecToTarget ); 
+
+	float quadTarget = target.LengthSqr();
+	float quadTargetXY = target.x*target.x + target.y*target.y;
+
+	// Target is too close!  Can't aim at it
+	if ( quadTarget > vecBarrelPos.LengthSqr() )
+	{
+		// We're trying to aim the offset barrel at an arbitrary point.
+		// To calculate this, I think of the target as being on a sphere with 
+		// it's center at the origin of the gun.
+		// The rotation we need is the opposite of the rotation that moves the target 
+		// along the surface of that sphere to intersect with the gun's shooting direction
+		// To calculate that rotation, we simply calculate the intersection of the ray 
+		// coming out of the barrel with the target sphere (that's the new target position)
+		// and use atan2() to get angles
+
+		// angles from target pos to center
+		float targetToCenterYaw = atan2( target.y, target.x );
+		float centerToGunYaw = atan2( vecBarrelPos.y, sqrt( quadTarget - (vecBarrelPos.y*vecBarrelPos.y) ) );
+
+		float targetToCenterPitch = atan2( target.z, sqrt( quadTargetXY ) );
+		float centerToGunPitch = atan2( -vecBarrelPos.z, sqrt( quadTarget - (vecBarrelPos.z*vecBarrelPos.z) ) );
+
+		QAngle angles;
+		angles.Init( RAD2DEG(targetToCenterPitch+centerToGunPitch), RAD2DEG( targetToCenterYaw + centerToGunYaw ), 0 );
+
+		float flNewAngle = AngleNormalize( UTIL_ApproachAngle( angles.x, m_hContainer->GetPoseParameter(m_poseWeapon_Pitch), DROPSHIP_GUN_SPEED));
+		m_hContainer->SetPoseParameter( m_poseWeapon_Pitch, flNewAngle );
+
+		flNewAngle = AngleNormalize( UTIL_ApproachAngle( angles.y, m_hContainer->GetPoseParameter(m_poseWeapon_Yaw), DROPSHIP_GUN_SPEED));
+		m_hContainer->SetPoseParameter( m_poseWeapon_Yaw, flNewAngle );
+		m_hContainer->StudioFrameAdvance();
+	}
+
+	vecToTarget -= vecMuzzle;
+	*flTargetRange = VectorNormalize( vecToTarget );
+	AngleVectors( vecAngles, &vecAimDir );
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose: Fire a round from the cannon
+// Notes:	Only call this if you have an enemy.
+//			Returns true if the cannon round was actually fired
+//------------------------------------------------------------------------------
+bool CNPC_CombineDropship::FireCannonRound( void )
+{
+	// Try and aim my cannon at the enemy, if I have a container
+	if ( !m_hContainer || (m_iCrateType < 0) )
+		return false;
+
+	// Update the container gun, and get the vector to the enemy, and the gun's current aim direction
+	float flRange;
+	Vector vecMuzzle, vecAimDir, vecToEnemy;
+	UpdateContainerGunFacing( vecMuzzle, vecToEnemy, vecAimDir, &flRange );
+	
+	// Out of range?
+	if ( flRange > m_flGunRange )
+		return false;
+
+	// Only fire if the target's close enough to our aim direction
+	float flCosAngle = DotProduct( vecToEnemy, vecAimDir );
+	if ( flCosAngle < DOT_15DEGREE )
+	{
+		m_flTimeNextAttack = gpGlobals->curtime + 0.1;
+		return false;
+	}
+
+	// If we're out of rounds, reload
+	if ( m_iBurstRounds <= 0 )
+	{
+		m_iBurstRounds = RandomInt( 10, 20 );
+		m_flTimeNextAttack = gpGlobals->curtime + (m_iBurstRounds * 0.1);
+		return false;
+	}
+
+	// HACK: Return true so the fire sound isn't stopped
+	if ( m_flTimeNextAttack > gpGlobals->curtime )
+		return true;
+
+	m_iBurstRounds--;
+
+	// If we're not currently firing, start it up
+	if ( !m_bIsFiring )
+	{
+		StartCannon();
+	}
+
+	// Add a muzzle flash
+	QAngle vecAimAngles;
+	VectorAngles( vecAimDir, vecAimAngles );
+	g_pEffects->MuzzleFlash( vecMuzzle, vecAimAngles, random->RandomFloat( 5.0f, 7.0f ), MUZZLEFLASH_TYPE_GUNSHIP );
+	m_flTimeNextAttack = gpGlobals->curtime + 0.05;
+
+	// Clamp to account for inaccuracy in aiming w/ pose parameters
+	vecAimDir = vecToEnemy;
+
+	// Fire the bullet
+	int ammoType = GetAmmoDef()->Index("CombineCannon"); 
+	FireBullets( 1, vecMuzzle, vecAimDir, VECTOR_CONE_2DEGREES, 8192, ammoType, 1, -1, -1, sk_npc_dmg_dropship.GetInt() );
+
+	return true;
+}
+
+//------------------------------------------------------------------------------
+// Scare AIs in the area where bullets are impacting
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::DoImpactEffect( trace_t &tr, int nDamageType )
+{
+	CSoundEnt::InsertSound( SOUND_DANGER | SOUND_CONTEXT_REACT_TO_SOURCE, tr.endpos, 120.0f, 0.3f, this );
+
+	BaseClass::DoImpactEffect( tr, nDamageType );
+}
+
+//------------------------------------------------------------------------------
+// Purpose : The proper way to begin the gunship cannon firing at the enemy.
+// Input   : 
+//		   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::StartCannon( void )
+{
+	m_bIsFiring = true;
+
+	// Start up the cannon sound.
+	if ( m_pCannonSound )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		controller.SoundChangeVolume(m_pCannonSound, 1.0, 0.0);
+	}
+
+}
+
+//------------------------------------------------------------------------------
+// Purpose : The proper way to cease the gunship cannon firing. 
+// Input   : 
+//		   :
+// Output  :
+//------------------------------------------------------------------------------
+void CNPC_CombineDropship::StopCannon( void )
+{
+	m_bIsFiring = false;
+
+	// Stop the cannon sound.
+	if ( m_pCannonSound )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		controller.SoundChangeVolume(m_pCannonSound, 0.0, 0.1);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Used the gunship's tracer for now
+//-----------------------------------------------------------------------------
+void CNPC_CombineDropship::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
+{
+	switch ( iTracerType )
+	{
+	case TRACER_LINE:
+		{
+			float flTracerDist;
+			Vector vecDir;
+			Vector vecEndPos;
+
+			vecDir = tr.endpos - vecTracerSrc;
+
+			flTracerDist = VectorNormalize( vecDir );
+
+			UTIL_Tracer( vecTracerSrc, tr.endpos, 0, TRACER_DONT_USE_ATTACHMENT, 16000, true, "GunshipTracer" );
+		}
+		break;
+
+	default:
+		BaseClass::MakeTracer( vecTracerSrc, tr, iTracerType );
+		break;
+	}
+}
+
+AI_BEGIN_CUSTOM_NPC( npc_combinedropship, CNPC_CombineDropship )
+
+	DECLARE_ACTIVITY( ACT_DROPSHIP_FLY_IDLE );
+	DECLARE_ACTIVITY( ACT_DROPSHIP_FLY_IDLE_EXAGG );
+	DECLARE_ACTIVITY( ACT_DROPSHIP_DESCEND_IDLE );
+	DECLARE_ACTIVITY( ACT_DROPSHIP_DEPLOY_IDLE );
+	DECLARE_ACTIVITY( ACT_DROPSHIP_LIFTOFF );
+
+	DECLARE_ACTIVITY( ACT_DROPSHIP_FLY_IDLE_CARGO );
+
+AI_END_CUSTOM_NPC()
+
+
+