HL2Overcharged/game/server/episodic/npc_combine_cannon.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"
#include "ai_basenpc.h"
#include "ammodef.h"
#include "ai_memory.h"
#include "weapon_rpg.h"
#include "effect_color_tables.h"
#include "te_effect_dispatch.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

extern const char* g_pModelNameLaser;

// No model, impervious to damage.
#define SF_STARTDISABLED	(1 << 19)

#define CANNON_PAINT_ENEMY_TIME			1.0f
#define CANNON_SUBSEQUENT_PAINT_TIME	0.4f
#define	CANNON_PAINT_NPC_TIME_NOISE		1.0f

#define	NUM_ANCILLARY_BEAMS	4

int gHaloTexture = 0;

//-----------------------------------------------------------------------------
//
// Combine Cannon
//
//-----------------------------------------------------------------------------
class CNPC_Combine_Cannon : public CAI_BaseNPC
{
	DECLARE_CLASS(CNPC_Combine_Cannon, CAI_BaseNPC);

public:
	CNPC_Combine_Cannon(void);
	virtual void		Precache(void);
	virtual void		Spawn(void);
	virtual Class_T		Classify(void);
	virtual float		MaxYawSpeed(void);
	virtual Vector		EyePosition(void);
	virtual void		UpdateOnRemove(void);
	virtual int			OnTakeDamage_Alive(const CTakeDamageInfo &info);
	virtual bool		QuerySeeEntity(CBaseEntity *pEntity, bool bOnlyHateOrFearIfNPC = false);
	virtual void		StartTask(const Task_t *pTask);
	virtual void		RunTask(const Task_t *pTask);
	virtual int			RangeAttack1Conditions(float flDot, float flDist);
	virtual int			SelectSchedule(void);
	virtual int			TranslateSchedule(int scheduleType);
	virtual void		PrescheduleThink(void);
	virtual bool		FCanCheckAttacks(void);
	virtual int			Restore(IRestore &restore);
	virtual void		OnScheduleChange(void);
	virtual bool		FVisible(CBaseEntity *pEntity, int traceMask = MASK_BLOCKLOS, CBaseEntity **ppBlocker = NULL);

	virtual bool		WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions) { return true; }

	virtual int			GetSoundInterests(void) { return (SOUND_PLAYER | SOUND_COMBAT | SOUND_DANGER); }

	virtual bool		ShouldNotDistanceCull(void) { return true; }

	virtual void		UpdateEfficiency(bool bInPVS)	{ SetEfficiency((GetSleepState() != AISS_AWAKE) ? AIE_DORMANT : AIE_NORMAL); SetMoveEfficiency(AIME_NORMAL); }

	virtual const char *GetTracerType(void) { return "HelicopterTracer"; }

private:

	void	ScopeGlint(void);
	void	AdjustShotPosition(CBaseEntity *pTarget, Vector *vecIn);

	float	GetRefireTime(void) { return 0.1f; }

	bool IsLaserOn(void) { return m_pBeam != NULL; }
	bool FireBullet(const Vector &vecTarget, bool bDirectShot);
	Vector  DesiredBodyTarget(CBaseEntity *pTarget);
	Vector	LeadTarget(CBaseEntity *pTarget);
	Vector GetBulletOrigin(void);

	static const char *pAttackSounds[];

	void ClearTargetGroup(void);

	float GetWaitTimePercentage(float flTime, bool fLinear);

	void GetPaintAim(const Vector &vecStart, const Vector &vecGoal, float flParameter, Vector *pProgress);

	bool VerifyShot(CBaseEntity *pTarget);

	void SetSweepTarget(const char *pszTarget);

	// Inputs
	void InputEnableSniper(inputdata_t &inputdata);
	void InputDisableSniper(inputdata_t &inputdata);

	void LaserOff(void);
	void LaserOn(const Vector &vecTarget, const Vector &vecDeviance);

	void PaintTarget(const Vector &vecTarget, float flPaintTime);

private:

	void	CreateLaser(void);
	void	CreateAncillaryBeams(void);
	void	UpdateAncillaryBeams(float flConvergencePerc, const Vector &vecOrigin, const Vector &vecBasis);

	int		m_iAmmoType;
	float	m_flBarrageDuration;
	Vector	m_vecPaintCursor;
	float	m_flPaintTime;

	CHandle<CBeam>				m_pBeam;
	CHandle<CBeam>				m_pAncillaryBeams[NUM_ANCILLARY_BEAMS];
	EHANDLE						m_hBarrageTarget;

	bool						m_fEnabled;
	Vector						m_vecPaintStart; // used to track where a sweep starts for the purpose of interpolating.
	float						m_flTimeLastAttackedPlayer;
	float						m_flTimeLastShotMissed;
	float						m_flSightDist;

	DEFINE_CUSTOM_AI;

	DECLARE_DATADESC();
};

LINK_ENTITY_TO_CLASS(npc_combine_cannon, CNPC_Combine_Cannon);

//=========================================================
//=========================================================
BEGIN_DATADESC(CNPC_Combine_Cannon)

DEFINE_FIELD(m_fEnabled, FIELD_BOOLEAN),
DEFINE_FIELD(m_vecPaintStart, FIELD_POSITION_VECTOR),
DEFINE_FIELD(m_flPaintTime, FIELD_TIME),
DEFINE_FIELD(m_vecPaintCursor, FIELD_POSITION_VECTOR),
DEFINE_FIELD(m_pBeam, FIELD_EHANDLE),
DEFINE_FIELD(m_flTimeLastAttackedPlayer, FIELD_TIME),
DEFINE_FIELD(m_flTimeLastShotMissed, FIELD_TIME),
DEFINE_FIELD(m_iAmmoType, FIELD_INTEGER),
DEFINE_FIELD(m_flBarrageDuration, FIELD_TIME),
DEFINE_FIELD(m_hBarrageTarget, FIELD_EHANDLE),

DEFINE_ARRAY(m_pAncillaryBeams, FIELD_EHANDLE, NUM_ANCILLARY_BEAMS),

DEFINE_KEYFIELD(m_flSightDist, FIELD_FLOAT, "sightdist"),
// Inputs
DEFINE_INPUTFUNC(FIELD_VOID, "EnableSniper", InputEnableSniper),
DEFINE_INPUTFUNC(FIELD_VOID, "DisableSniper", InputDisableSniper),

END_DATADESC()


//=========================================================
// Private conditions
//=========================================================
enum Sniper_Conds
{
	COND_CANNON_ENABLED = LAST_SHARED_CONDITION,
	COND_CANNON_DISABLED,
	COND_CANNON_NO_SHOT,
};


//=========================================================
// schedules
//=========================================================
enum
{
	SCHED_CANNON_CAMP = LAST_SHARED_SCHEDULE,
	SCHED_CANNON_ATTACK,
	SCHED_CANNON_DISABLEDWAIT,
	SCHED_CANNON_SNAPATTACK,
};

//=========================================================
// tasks
//=========================================================
enum
{
	TASK_CANNON_PAINT_ENEMY = LAST_SHARED_TASK,
	TASK_CANNON_PAINT_DECOY,
	TASK_CANNON_ATTACK_CURSOR,
};

//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CNPC_Combine_Cannon::CNPC_Combine_Cannon(void) :
m_pBeam(NULL),
m_hBarrageTarget(NULL)
{
#ifdef _DEBUG
	m_vecPaintCursor.Init();
	m_vecPaintStart.Init();
#endif
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CNPC_Combine_Cannon::QuerySeeEntity(CBaseEntity *pEntity, bool bOnlyHateOrFearIfNPC)
{
	Disposition_t disp = IRelationType(pEntity);
	if (disp != D_HT)
	{
		// Don't bother with anything I wouldn't shoot.
		return false;
	}

	if (!FInViewCone(pEntity))
	{
		// Yes, this does call FInViewCone twice a frame for all entities checked for 
		// visibility, but doing this allows us to cut out a bunch of traces that would
		// be done by VerifyShot for entities that aren't even in our viewcone.
		return false;
	}

	if (VerifyShot(pEntity))
		return BaseClass::QuerySeeEntity(pEntity, bOnlyHateOrFearIfNPC);

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Hide the beams
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::LaserOff(void)
{
	if (m_pBeam != NULL)
	{
		m_pBeam->TurnOn();
	}

	for (int i = 0; i < NUM_ANCILLARY_BEAMS; i++)
	{
		if (m_pAncillaryBeams[i] == NULL)
			continue;

		m_pAncillaryBeams[i]->TurnOn();
	}

	SetNextThink(gpGlobals->curtime + 0.1f);
}


//-----------------------------------------------------------------------------
// Purpose: Switch on the laser and point it at a direction
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::LaserOn(const Vector &vecTarget, const Vector &vecDeviance)
{
	if (m_pBeam != NULL)
	{
		m_pBeam->TurnOff();

		// Don't aim right at the guy right now.
		Vector vecInitialAim;

		if (vecDeviance == vec3_origin)
		{
			// Start the aim where it last left off!
			vecInitialAim = m_vecPaintCursor;
		}
		else
		{
			vecInitialAim = vecTarget;
		}

		vecInitialAim.x += random->RandomFloat(-vecDeviance.x, vecDeviance.x);
		vecInitialAim.y += random->RandomFloat(-vecDeviance.y, vecDeviance.y);
		vecInitialAim.z += random->RandomFloat(-vecDeviance.z, vecDeviance.z);

		m_pBeam->SetStartPos(GetBulletOrigin());
		m_pBeam->SetEndPos(vecInitialAim);

		m_vecPaintStart = vecInitialAim;
	}

	for (int i = 0; i < NUM_ANCILLARY_BEAMS; i++)
	{
		if (m_pAncillaryBeams[i] == NULL)
			continue;

		m_pAncillaryBeams[i]->TurnOff();
	}
}

//-----------------------------------------------------------------------------
// Crikey!
//-----------------------------------------------------------------------------
float CNPC_Combine_Cannon::GetWaitTimePercentage(float flTime, bool fLinear)
{
	float flElapsedTime;
	float flTimeParameter;

	flElapsedTime = flTime - (GetWaitFinishTime() - gpGlobals->curtime);

	flTimeParameter = (flElapsedTime / flTime);

	if (fLinear)
	{
		return flTimeParameter;
	}
	else
	{
		return (1 + sin((M_PI * flTimeParameter) - (M_PI / 2))) / 2;
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::GetPaintAim(const Vector &vecStart, const Vector &vecGoal, float flParameter, Vector *pProgress)
{
	// Quaternions
	Vector vecIdealDir;
	QAngle vecIdealAngles;
	QAngle vecCurrentAngles;
	Vector vecCurrentDir;
	Vector vecBulletOrigin = GetBulletOrigin();

	// vecIdealDir is where the gun should be aimed when the painting
	// time is up. This can be approximate. This is only for drawing the
	// laser, not actually aiming the weapon. A large discrepancy will look
	// bad, though.
	vecIdealDir = vecGoal - vecBulletOrigin;
	VectorNormalize(vecIdealDir);

	// Now turn vecIdealDir into angles!
	VectorAngles(vecIdealDir, vecIdealAngles);

	// This is the vector of the beam's current aim.
	vecCurrentDir = m_vecPaintStart - vecBulletOrigin;
	VectorNormalize(vecCurrentDir);

	// Turn this to angles, too.
	VectorAngles(vecCurrentDir, vecCurrentAngles);

	Quaternion idealQuat;
	Quaternion currentQuat;
	Quaternion aimQuat;

	AngleQuaternion(vecIdealAngles, idealQuat);
	AngleQuaternion(vecCurrentAngles, currentQuat);

	QuaternionSlerp(currentQuat, idealQuat, flParameter, aimQuat);

	QuaternionAngles(aimQuat, vecCurrentAngles);

	// Rebuild the current aim vector.
	AngleVectors(vecCurrentAngles, &vecCurrentDir);

	*pProgress = vecCurrentDir;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::CreateLaser(void)
{
	if (m_pBeam != NULL)
		return;

	m_pBeam = CBeam::BeamCreate(g_pModelNameLaser, 2.0f);

	m_pBeam->SetColor(0, 100, 255);

	m_pBeam->PointsInit(vec3_origin, GetBulletOrigin());
	m_pBeam->SetBrightness(255);
	m_pBeam->SetNoise(0);
	m_pBeam->SetWidth(1.0f);
	m_pBeam->SetEndWidth(0);
	m_pBeam->SetScrollRate(0);
	m_pBeam->SetFadeLength(0);
	m_pBeam->SetHaloTexture(gHaloTexture);
	m_pBeam->SetHaloScale(16.0f);

	// Think faster while painting
	SetNextThink(gpGlobals->curtime + 0.02f);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::CreateAncillaryBeams(void)
{
	for (int i = 0; i < NUM_ANCILLARY_BEAMS; i++)
	{
		if (m_pAncillaryBeams[i] != NULL)
			continue;

		m_pAncillaryBeams[i] = CBeam::BeamCreate(g_pModelNameLaser, 2.0f);
		m_pAncillaryBeams[i]->SetColor(0, 100, 255);

		m_pAncillaryBeams[i]->PointsInit(vec3_origin, GetBulletOrigin());
		m_pAncillaryBeams[i]->SetBrightness(255);
		m_pAncillaryBeams[i]->SetNoise(0);
		m_pAncillaryBeams[i]->SetWidth(1.0f);
		m_pAncillaryBeams[i]->SetEndWidth(0);
		m_pAncillaryBeams[i]->SetScrollRate(0);
		m_pAncillaryBeams[i]->SetFadeLength(0);
		m_pAncillaryBeams[i]->SetHaloTexture(gHaloTexture);
		m_pAncillaryBeams[i]->SetHaloScale(16.0f);
		m_pAncillaryBeams[i]->TurnOff();
	}
}

#define LINE_LENGTH 1600.0f

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : flConvergencePerc - 
//			vecBasis - 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::UpdateAncillaryBeams(float flConvergencePerc, const Vector &vecOrigin, const Vector &vecBasis)
{
	// Multiple beams deviate from the basis direction by a certain number of degrees and "converge" 
	// at the basis vector over a duration of time, the position in that duration expressed by 
	// flConvergencePerc.  The beams are most deviated at 0 and fully converged at 1.

	float flRotationOffset = (2 * M_PI) / (float)NUM_ANCILLARY_BEAMS; // Degrees separating each beam, in radians
	float flDeviation = DEG2RAD(90) * (1.0f - flConvergencePerc);
	float flOffset;
	Vector vecFinal;
	Vector vecOffset;

	matrix3x4_t matRotate;
	QAngle vecAngles;
	VectorAngles(vecBasis, vecAngles);
	vecAngles[PITCH] += 90.0f;
	AngleMatrix(vecAngles, vecOrigin, matRotate);

	trace_t	tr;

	float flScale = LINE_LENGTH * flDeviation;

	// For each beam, find its offset and trace outwards to place its endpoint
	for (int i = 0; i < NUM_ANCILLARY_BEAMS; i++)
	{
		if (flConvergencePerc >= 0.99f)
		{
			m_pAncillaryBeams[i]->TurnOn();
			continue;
		}

		m_pAncillaryBeams[i]->TurnOff();

		// Find the number of radians offset we are
		flOffset = (float)i * flRotationOffset + DEG2RAD(30.0f);
		flOffset += (M_PI / 8.0f) * sin(gpGlobals->curtime * 3.0f);

		// Construct a circle that's also offset by the line's length
		vecOffset.x = cos(flOffset) * flScale;
		vecOffset.y = sin(flOffset) * flScale;
		vecOffset.z = LINE_LENGTH;

		// Rotate this whole thing into the space of the basis vector
		VectorRotate(vecOffset, matRotate, vecFinal);
		VectorNormalize(vecFinal);

		// Trace a line down that vector to find where we'll eventually stop our line
		UTIL_TraceLine(vecOrigin, vecOrigin + (vecFinal * LINE_LENGTH), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

		// Move the beam to that position
		m_pAncillaryBeams[i]->SetBrightness(255.0f * flConvergencePerc);
		m_pAncillaryBeams[i]->SetEndPos(tr.startpos);
		m_pAncillaryBeams[i]->SetStartPos(tr.endpos);
	}
}

//-----------------------------------------------------------------------------
// Sweep the laser sight towards the point where the gun should be aimed
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::PaintTarget(const Vector &vecTarget, float flPaintTime)
{
	// vecStart is the barrel of the gun (or the laser sight)
	Vector vecStart = GetBulletOrigin();

	// keep painttime from hitting 0 exactly.
	flPaintTime = MAX(flPaintTime, 0.000001f);

	// Find out where we are in the arc of the paint duration
	float flPaintPerc = GetWaitTimePercentage(flPaintTime, false);

	ScopeGlint();

	// Find out where along our line we're painting
	Vector vecCurrentDir;
	float flInterp = RemapValClamped(flPaintPerc, 0.0f, 0.5f, 0.0f, 1.0f);
	flInterp = clamp(flInterp, 0.0f, 1.0f);
	GetPaintAim(m_vecPaintStart, vecTarget, flInterp, &vecCurrentDir);

#define THRESHOLD 0.9f
	float flNoiseScale;

	if (flPaintPerc >= THRESHOLD)
	{
		flNoiseScale = 1 - (1 / (1 - THRESHOLD)) * (flPaintPerc - THRESHOLD);
	}
	else if (flPaintPerc <= 1 - THRESHOLD)
	{
		flNoiseScale = flPaintPerc / (1 - THRESHOLD);
	}
	else
	{
		flNoiseScale = 1;
	}

	// mult by P
	vecCurrentDir.x += flNoiseScale * (sin(3 * M_PI * gpGlobals->curtime) * 0.0006);
	vecCurrentDir.y += flNoiseScale * (sin(2 * M_PI * gpGlobals->curtime + 0.5 * M_PI) * 0.0006);
	vecCurrentDir.z += flNoiseScale * (sin(1.5 * M_PI * gpGlobals->curtime + M_PI) * 0.0006);

	// Find where our center is
	trace_t tr;
	UTIL_TraceLine(vecStart, vecStart + vecCurrentDir * 8192, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
	m_vecPaintCursor = tr.endpos;

	// Update our beam position
	m_pBeam->SetEndPos(tr.startpos);
	m_pBeam->SetStartPos(tr.endpos);
	m_pBeam->SetBrightness(255.0f * flPaintPerc);
	m_pBeam->RelinkBeam();

	// Find points around that center point and make our designators converge at that point over time
	UpdateAncillaryBeams(flPaintPerc, vecStart, vecCurrentDir);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::OnScheduleChange(void)
{
	LaserOff();

	m_hBarrageTarget = NULL;

	BaseClass::OnScheduleChange();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::Precache(void)
{
	PrecacheModel("models/combine_soldier.mdl");
	PrecacheModel("effects/bluelaser1.vmt");

	gHaloTexture = PrecacheModel("sprites/light_glow03.vmt");

	PrecacheScriptSound("NPC_Combine_Cannon.FireBullet");

	BaseClass::Precache();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::Spawn(void)
{
	Precache();

	/// HACK:
	SetModel("models/combine_soldier.mdl");

	// Setup our ancillary beams but keep them hidden for now
	CreateLaser();
	CreateAncillaryBeams();

	m_iAmmoType = GetAmmoDef()->Index("CombineHeavyCannon");

	SetHullType(HULL_HUMAN);
	SetHullSizeNormal();

	UTIL_SetSize(this, Vector(-16, -16, 0), Vector(16, 16, 64));

	SetSolid(SOLID_BBOX);
	AddSolidFlags(FSOLID_NOT_STANDABLE);
	SetMoveType(MOVETYPE_FLY);
	m_bloodColor = DONT_BLEED;
	m_iHealth = 10;
	m_flFieldOfView = DOT_45DEGREE;
	m_NPCState = NPC_STATE_NONE;

	if (HasSpawnFlags(SF_STARTDISABLED))
	{
		m_fEnabled = false;
	}
	else
	{
		m_fEnabled = true;
	}

	CapabilitiesClear();
	CapabilitiesAdd(bits_CAP_INNATE_RANGE_ATTACK1 | bits_CAP_SIMPLE_RADIUS_DAMAGE);

	m_HackedGunPos = Vector(0, 0, 0);

	AddSpawnFlags(SF_NPC_LONG_RANGE | SF_NPC_ALWAYSTHINK);

	NPCInit();

	// Limit our look distance
	SetDistLook(m_flSightDist);

	AddEffects(EF_NODRAW);
	AddSolidFlags(FSOLID_NOT_SOLID);

	// Point the cursor straight ahead so that the sniper's
	// first sweep of the laser doesn't look weird.
	Vector vecForward;
	AngleVectors(GetLocalAngles(), &vecForward);
	m_vecPaintCursor = GetBulletOrigin() + vecForward * 1024;

	// none!
	GetEnemies()->SetFreeKnowledgeDuration(0.0f);
	GetEnemies()->SetEnemyDiscardTime(2.0f);

	m_flTimeLastAttackedPlayer = 0.0f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Class_T	CNPC_Combine_Cannon::Classify(void)
{
	if (m_fEnabled)
		return	CLASS_COMBINE;

	return CLASS_NONE;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
Vector CNPC_Combine_Cannon::GetBulletOrigin(void)
{
	return GetAbsOrigin();
}


//-----------------------------------------------------------------------------
// Purpose: Nothing kills the cannon but entity I/O
//-----------------------------------------------------------------------------
int CNPC_Combine_Cannon::OnTakeDamage_Alive(const CTakeDamageInfo &info)
{
	// We are invulnerable to normal attacks for the moment
	return 0;
}

//---------------------------------------------------------
// Purpose: 
//---------------------------------------------------------
void CNPC_Combine_Cannon::UpdateOnRemove(void)
{
	// Remove the main laser
	if (m_pBeam != NULL)
	{
		UTIL_Remove(m_pBeam);
		m_pBeam = NULL;
	}

	// Remove our ancillary beams
	for (int i = 0; i < NUM_ANCILLARY_BEAMS; i++)
	{
		if (m_pAncillaryBeams[i] == NULL)
			continue;

		UTIL_Remove(m_pAncillaryBeams[i]);
		m_pAncillaryBeams[i] = NULL;
	}

	BaseClass::UpdateOnRemove();
}

//---------------------------------------------------------
// Purpose: 
//---------------------------------------------------------
int CNPC_Combine_Cannon::SelectSchedule(void)
{
	// Fire at our target
	if (GetEnemy() && HasCondition(COND_CAN_RANGE_ATTACK1))
		return SCHED_RANGE_ATTACK1;

	// Wait for a target
	// TODO: Sweep like a sniper?
	return SCHED_COMBAT_STAND;
}

//---------------------------------------------------------
// Purpose: 
//---------------------------------------------------------
bool CNPC_Combine_Cannon::FCanCheckAttacks(void)
{
	return true;
}


//---------------------------------------------------------
//---------------------------------------------------------
bool CNPC_Combine_Cannon::VerifyShot(CBaseEntity *pTarget)
{
	trace_t tr;

	Vector vecTarget = DesiredBodyTarget(pTarget);
	UTIL_TraceLine(GetBulletOrigin(), vecTarget, MASK_SHOT, pTarget, COLLISION_GROUP_NONE, &tr);

	if (tr.fraction != 1.0)
	{
		if (pTarget->IsPlayer())
		{
			// if the target is the player, do another trace to see if we can shoot his eyeposition. This should help 
			// improve sniper responsiveness in cases where the player is hiding his chest from the sniper with his 
			// head in full view.
			UTIL_TraceLine(GetBulletOrigin(), pTarget->EyePosition(), MASK_SHOT, pTarget, COLLISION_GROUP_NONE, &tr);

			if (tr.fraction == 1.0)
			{
				return true;
			}
		}

		// Trace hit something.
		if (tr.m_pEnt)
		{
			if (tr.m_pEnt->m_takedamage == DAMAGE_YES)
			{
				// Just shoot it if I can hurt it. Probably a breakable or glass pane.
				return true;
			}
		}

		return false;
	}
	else
	{
		return true;
	}
}

//---------------------------------------------------------
//---------------------------------------------------------
int CNPC_Combine_Cannon::RangeAttack1Conditions(float flDot, float flDist)
{
	if (GetNextAttack() > gpGlobals->curtime)
		return COND_NONE;

	if (HasCondition(COND_SEE_ENEMY) && !HasCondition(COND_ENEMY_OCCLUDED))
	{
		if (VerifyShot(GetEnemy()))
		{
			// Can see the enemy, have a clear shot to his midsection
			ClearCondition(COND_CANNON_NO_SHOT);
			return COND_CAN_RANGE_ATTACK1;
		}
		else
		{
			// Can see the enemy, but can't take a shot at his midsection
			SetCondition(COND_CANNON_NO_SHOT);
			return COND_NONE;
		}
	}

	return COND_NONE;
}


//---------------------------------------------------------
//---------------------------------------------------------
int CNPC_Combine_Cannon::TranslateSchedule(int scheduleType)
{
	switch (scheduleType)
	{
	case SCHED_RANGE_ATTACK1:
		return SCHED_CANNON_ATTACK;
		break;
	}
	return BaseClass::TranslateSchedule(scheduleType);
}

//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::ScopeGlint(void)
{
	CEffectData data;

	data.m_vOrigin = GetAbsOrigin();
	data.m_vNormal = vec3_origin;
	data.m_vAngles = vec3_angle;
	data.m_nColor = COMMAND_POINT_BLUE;

	DispatchEffect("CommandPointer", data);
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *vecIn - 
//-----------------------------------------------------------------------------
void CNPC_Combine_Cannon::AdjustShotPosition(CBaseEntity *pTarget, Vector *vecIn)
{
	if (pTarget == NULL || vecIn == NULL)
		return;

	Vector low = pTarget->WorldSpaceCenter() - (pTarget->WorldSpaceCenter() - pTarget->GetAbsOrigin()) * .25;
	Vector high = pTarget->EyePosition();
	Vector delta = high - low;
	Vector result = low + delta * 0.5;

	// Only take the height
	(*vecIn)[2] = result[2];
}

//---------------------------------------------------------
// This starts the bullet state machine.  The actual effects
// of the bullet will happen later.  This function schedules 
// those effects.
//
// fDirectShot indicates whether the bullet is a "direct shot"
// that is - fired with the intent that it will strike the
// enemy. Otherwise, the bullet is intended to strike a 
// decoy object or nothing at all in particular.
//---------------------------------------------------------
bool CNPC_Combine_Cannon::FireBullet(const Vector &vecTarget, bool bDirectShot)
{
	Vector vecBulletOrigin = GetBulletOrigin();
	Vector vecDir = (vecTarget - vecBulletOrigin);
	VectorNormalize(vecDir);

	FireBulletsInfo_t info;
	info.m_iShots = 1;
	info.m_iTracerFreq = 1.0f;
	info.m_vecDirShooting = vecDir;
	info.m_vecSrc = vecBulletOrigin;
	info.m_flDistance = MAX_TRACE_LENGTH;
	info.m_pAttacker = this;
	info.m_iAmmoType = m_iAmmoType;
	info.m_iPlayerDamage = 20.0f;
	info.m_vecSpread = Vector(0.015f, 0.015f, 0.015f);  // medium cone

	FireBullets(info);

	EmitSound("NPC_Combine_Cannon.FireBullet");

	// Don't attack for a certain amount of time
	SetNextAttack(gpGlobals->curtime + GetRefireTime());

	// Sniper had to be aiming here to fire here, so make it the cursor
	m_vecPaintCursor = vecTarget;

	LaserOff();

	return true;
}

//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::StartTask(const Task_t *pTask)
{
	switch (pTask->iTask)
	{
	case TASK_CANNON_ATTACK_CURSOR:
		break;

	case TASK_RANGE_ATTACK1:
		// Setup the information for this barrage
		m_flBarrageDuration = gpGlobals->curtime + random->RandomFloat(0.25f, 0.5f);
		m_hBarrageTarget = GetEnemy();
		break;

	case TASK_CANNON_PAINT_ENEMY:
	{
		if (GetEnemy()->IsPlayer())
		{
			float delay = random->RandomFloat(0.0f, 0.3f);

			if ((gpGlobals->curtime - m_flTimeLastAttackedPlayer) < 1.0f)
			{
				SetWait(CANNON_SUBSEQUENT_PAINT_TIME);
				m_flPaintTime = CANNON_SUBSEQUENT_PAINT_TIME;
			}
			else
			{
				SetWait(CANNON_PAINT_ENEMY_TIME + delay);
				m_flPaintTime = CANNON_PAINT_ENEMY_TIME + delay;
			}
		}
		else
		{
			// Use a random time
			m_flPaintTime = CANNON_PAINT_ENEMY_TIME + random->RandomFloat(0, CANNON_PAINT_NPC_TIME_NOISE);
			SetWait(m_flPaintTime);
		}

		// Try to start the laser where the player can't miss seeing it!
		Vector vecCursor;
		AngleVectors(GetEnemy()->GetLocalAngles(), &vecCursor);
		vecCursor *= 300;
		vecCursor += GetEnemy()->EyePosition();
		LaserOn(vecCursor, Vector(16, 16, 16));
	}
	break;

	default:
		BaseClass::StartTask(pTask);
		break;
	}
}

//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::RunTask(const Task_t *pTask)
{
	switch (pTask->iTask)
	{
	case TASK_CANNON_ATTACK_CURSOR:
		if (FireBullet(m_vecPaintCursor, true))
		{
			TaskComplete();
		}
		break;

	case TASK_RANGE_ATTACK1:
	{
		// Where we're focusing our fire
		Vector vecTarget = (m_hBarrageTarget == NULL) ? m_vecPaintCursor : LeadTarget(m_hBarrageTarget);

		// Fire at enemy
		if (FireBullet(vecTarget, true))
		{
			bool bPlayerIsEnemy = (m_hBarrageTarget && m_hBarrageTarget->IsPlayer());
			bool bBarrageFinished = m_flBarrageDuration < gpGlobals->curtime;
			bool bNoShot = (QuerySeeEntity(m_hBarrageTarget) == false);	// FIXME: Store this info off better
			bool bSeePlayer = HasCondition(COND_SEE_PLAYER);

			// Treat the player differently to normal NPCs
			if (bPlayerIsEnemy)
			{
				// Store the last time we shot for doing an abbreviated attack telegraph
				m_flTimeLastAttackedPlayer = gpGlobals->curtime;

				// If we've got no shot and we're done with our current barrage
				if (bNoShot && bBarrageFinished)
				{
					TaskComplete();
				}
			}
			else if (bBarrageFinished || bSeePlayer)
			{
				// Done with the barrage or we saw the player as a better target
				TaskComplete();
			}
		}
	}
	break;

	case TASK_CANNON_PAINT_ENEMY:
	{
		// See if we're done painting our target
		if (IsWaitFinished())
		{
			TaskComplete();
		}

		// Continue to paint the target
		PaintTarget(LeadTarget(GetEnemy()), m_flPaintTime);
	}
	break;

	default:
		BaseClass::RunTask(pTask);
		break;
	}
}


//-----------------------------------------------------------------------------
// The sniper throws away the circular list of old decoys when we restore.
//-----------------------------------------------------------------------------
int CNPC_Combine_Cannon::Restore(IRestore &restore)
{
	return BaseClass::Restore(restore);
}


//-----------------------------------------------------------------------------
// Purpose: 
//
//
//-----------------------------------------------------------------------------
float CNPC_Combine_Cannon::MaxYawSpeed(void)
{
	return 60;
}

//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::PrescheduleThink(void)
{
	BaseClass::PrescheduleThink();

	// NOTE: We'll deal with this on the client
	// Think faster if the beam is on, this gives the beam higher resolution.
	if (m_pBeam)
	{
		SetNextThink(gpGlobals->curtime + 0.03);
	}
	else
	{
		SetNextThink(gpGlobals->curtime + 0.1f);
	}

	// If the enemy has just stepped into view, or we've acquired a new enemy,
	// Record the last time we've seen the enemy as right now.
	//
	// If the enemy has been out of sight for a full second, mark him eluded.
	if (GetEnemy() != NULL)
	{
		if (gpGlobals->curtime - GetEnemies()->LastTimeSeen(GetEnemy()) > 30)
		{
			// Stop pestering enemies after 30 seconds of frustration.
			GetEnemies()->ClearMemory(GetEnemy());
			SetEnemy(NULL);
		}
	}
}


//---------------------------------------------------------
//---------------------------------------------------------
Vector CNPC_Combine_Cannon::EyePosition(void)
{
	return GetAbsOrigin();
}

//---------------------------------------------------------
//---------------------------------------------------------
Vector CNPC_Combine_Cannon::DesiredBodyTarget(CBaseEntity *pTarget)
{
	// By default, aim for the center
	Vector vecTarget = pTarget->WorldSpaceCenter();

	float flTimeSinceLastMiss = gpGlobals->curtime - m_flTimeLastShotMissed;

	if (pTarget->GetFlags() & FL_CLIENT)
	{
		if (!BaseClass::FVisible(vecTarget))
		{
			// go to the player's eyes if his center is concealed.
			// Bump up an inch so the player's not looking straight down a beam.
			vecTarget = pTarget->EyePosition() + Vector(0, 0, 1);
		}
	}
	else
	{
		if (pTarget->Classify() == CLASS_HEADCRAB)
		{
			// Headcrabs are tiny inside their boxes.
			vecTarget = pTarget->GetAbsOrigin();
			vecTarget.z += 4.0;
		}
		else if (pTarget->Classify() == CLASS_ZOMBIE)
		{
			if (flTimeSinceLastMiss > 0.0f && flTimeSinceLastMiss < 4.0f && hl2_episodic.GetBool())
			{
				vecTarget = pTarget->BodyTarget(GetBulletOrigin(), false);
			}
			else
			{
				// Shoot zombies in the headcrab
				vecTarget = pTarget->HeadTarget(GetBulletOrigin());
			}
		}
		else if (pTarget->Classify() == CLASS_ANTLION)
		{
			// Shoot about a few inches above the origin. This makes it easy to hit antlions
			// even if they are on their backs.
			vecTarget = pTarget->GetAbsOrigin();
			vecTarget.z += 18.0f;
		}
		else if (pTarget->Classify() == CLASS_EARTH_FAUNA)
		{
			// Shoot birds in the center
		}
		else
		{
			// Shoot NPCs in the chest
			vecTarget.z += 8.0f;
		}
	}

	return vecTarget;
}

//---------------------------------------------------------
//---------------------------------------------------------
Vector CNPC_Combine_Cannon::LeadTarget(CBaseEntity *pTarget)
{
	if (pTarget != NULL)
	{
		Vector vecFuturePos;
		UTIL_PredictedPosition(pTarget, 0.05f, &vecFuturePos);
		AdjustShotPosition(pTarget, &vecFuturePos);

		return vecFuturePos;
	}

	return vec3_origin;
}

//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::InputEnableSniper(inputdata_t &inputdata)
{
	ClearCondition(COND_CANNON_DISABLED);
	SetCondition(COND_CANNON_ENABLED);

	m_fEnabled = true;
}


//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Combine_Cannon::InputDisableSniper(inputdata_t &inputdata)
{
	ClearCondition(COND_CANNON_ENABLED);
	SetCondition(COND_CANNON_DISABLED);

	m_fEnabled = false;
}

//---------------------------------------------------------
// See all NPC's easily.
//
// Only see the player if you can trace to both of his 
// eyeballs. That is, allow the player to peek around corners.
// This is a little more expensive than the base class' check!
//---------------------------------------------------------
#define CANNON_EYE_DIST 0.75
#define CANNON_TARGET_VERTICAL_OFFSET Vector( 0, 0, 5 );
bool CNPC_Combine_Cannon::FVisible(CBaseEntity *pEntity, int traceMask, CBaseEntity **ppBlocker)
{
	// NPC
	if (pEntity->IsPlayer() == false)
		return BaseClass::FVisible(pEntity, traceMask, ppBlocker);

	if (pEntity->GetFlags() & FL_NOTARGET)
		return false;

	Vector	vecVerticalOffset;
	Vector	vecRight;
	Vector	vecEye;
	trace_t	tr;

	if (fabs(GetAbsOrigin().z - pEntity->WorldSpaceCenter().z) <= 120.f)
	{
		// If the player is around the same elevation, look straight at his eyes. 
		// At the same elevation, the vertical peeking allowance makes it too easy
		// for a player to dispatch the sniper from cover.
		vecVerticalOffset = vec3_origin;
	}
	else
	{
		// Otherwise, look at a spot below his eyes. This allows the player to back away
		// from his cover a bit and have a peek at the sniper without being detected.
		vecVerticalOffset = CANNON_TARGET_VERTICAL_OFFSET;
	}

	AngleVectors(pEntity->GetLocalAngles(), NULL, &vecRight, NULL);

	vecEye = vecRight * CANNON_EYE_DIST - vecVerticalOffset;
	UTIL_TraceLine(EyePosition(), pEntity->EyePosition() + vecEye, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

#if 0
	NDebugOverlay::Line(EyePosition(), tr.endpos, 0, 255, 0, true, 0.1);
#endif

	bool fCheckFailed = false;

	if (tr.fraction != 1.0 && tr.m_pEnt != pEntity)
	{
		fCheckFailed = true;
	}

	// Don't check the other eye if the first eye failed.
	if (!fCheckFailed)
	{
		vecEye = -vecRight * CANNON_EYE_DIST - vecVerticalOffset;
		UTIL_TraceLine(EyePosition(), pEntity->EyePosition() + vecEye, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

#if 0
		NDebugOverlay::Line(EyePosition(), tr.endpos, 0, 255, 0, true, 0.1);
#endif 

		if (tr.fraction != 1.0 && tr.m_pEnt != pEntity)
		{
			fCheckFailed = true;
		}
	}

	if (!fCheckFailed)
	{
		// Can see the player.
		return true;
	}

	// Now, if the check failed, see if the player is ducking and has recently
	// fired a muzzleflash. If yes, see if you'd be able to see the player if 
	// they were standing in their current position instead of ducking. Since
	// the sniper doesn't have a clear shot in this situation, he will harrass
	// near the player.
	CBasePlayer *pPlayer;

	pPlayer = ToBasePlayer(pEntity);

	if ((pPlayer->GetFlags() & FL_DUCKING) && pPlayer->MuzzleFlashTime() > gpGlobals->curtime)
	{
		vecEye = pPlayer->EyePosition() + Vector(0, 0, 32);
		UTIL_TraceLine(EyePosition(), vecEye, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);

		if (tr.fraction != 1.0)
		{
			// Everything failed.
			if (ppBlocker)
			{
				*ppBlocker = tr.m_pEnt;
			}
			return false;
		}
		else
		{
			// Fake being able to see the player.
			return true;
		}
	}

	if (ppBlocker)
	{
		*ppBlocker = tr.m_pEnt;
	}

	return false;
}


//-----------------------------------------------------------------------------
//
// Schedules
//
//-----------------------------------------------------------------------------

AI_BEGIN_CUSTOM_NPC(npc_combine_cannon, CNPC_Combine_Cannon)

DECLARE_CONDITION(COND_CANNON_ENABLED);
DECLARE_CONDITION(COND_CANNON_DISABLED);
DECLARE_CONDITION(COND_CANNON_NO_SHOT);

DECLARE_TASK(TASK_CANNON_PAINT_ENEMY);
DECLARE_TASK(TASK_CANNON_ATTACK_CURSOR);

//=========================================================
// CAMP
//=========================================================
DEFINE_SCHEDULE
(
SCHED_CANNON_CAMP,

"	Tasks"
"		TASK_WAIT		1"
"	"
"	Interrupts"
"		COND_NEW_ENEMY"
"		COND_ENEMY_DEAD"
"		COND_CAN_RANGE_ATTACK1"
"		COND_HEAR_DANGER"
"		COND_CANNON_DISABLED"
)

//=========================================================
// ATTACK
//=========================================================
DEFINE_SCHEDULE
(
SCHED_CANNON_ATTACK,

"	Tasks"
"		TASK_CANNON_PAINT_ENEMY		0"
"		TASK_RANGE_ATTACK1			0"
"	"
"	Interrupts"
"		COND_HEAR_DANGER"
"		COND_CANNON_DISABLED"
)

//=========================================================
// ATTACK
//=========================================================
DEFINE_SCHEDULE
(
SCHED_CANNON_SNAPATTACK,

"	Tasks"
"		TASK_CANNON_ATTACK_CURSOR	0"
"	"
"	Interrupts"
"		COND_ENEMY_OCCLUDED"
"		COND_ENEMY_DEAD"
"		COND_NEW_ENEMY"
"		COND_HEAR_DANGER"
"		COND_CANNON_DISABLED"
)

//=========================================================
// Sniper is allowed to process a couple conditions while
// disabled, but mostly he waits until he's enabled.
//=========================================================
DEFINE_SCHEDULE
(
SCHED_CANNON_DISABLEDWAIT,

"	Tasks"
"		TASK_WAIT			0.5"
"	"
"	Interrupts"
"		COND_CANNON_ENABLED"
"		COND_NEW_ENEMY"
"		COND_ENEMY_DEAD"
)

AI_END_CUSTOM_NPC()