|
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "soundent.h"
#include "game.h"
#include "beam_shared.h"
#include "Sprite.h"
#include "npcevent.h"
#include "npc_stalker.h"
#include "ai_hull.h"
#include "ai_default.h"
#include "ai_node.h"
#include "ai_network.h"
#include "ai_hint.h"
#include "ai_link.h"
#include "ai_waypoint.h"
#include "ai_navigator.h"
#include "ai_senses.h"
#include "ai_squadslot.h"
#include "ai_squad.h"
#include "ai_memory.h"
#include "ai_tacticalservices.h"
#include "ai_moveprobe.h"
#include "npc_talker.h"
#include "activitylist.h"
#include "bitstring.h"
#include "decals.h"
#include "player.h"
#include "entitylist.h"
#include "ndebugoverlay.h"
#include "ai_interactions.h"
#include "animation.h"
#include "scriptedtarget.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "world.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//#define STALKER_DEBUG
#define MIN_STALKER_FIRE_RANGE 64
#define MAX_STALKER_FIRE_RANGE 3600 // 3600 feet.
#define STALKER_LASER_ATTACHMENT 1
#define STALKER_TRIGGER_DIST 200 // Enemy dist. that wakes up the stalker
#define STALKER_SENTENCE_VOLUME (float)0.35
#define STALKER_LASER_DURATION 99999
#define STALKER_LASER_RECHARGE 1
#define STALKER_PLAYER_AGGRESSION 1
enum StalkerBeamPower_e { STALKER_BEAM_LOW, STALKER_BEAM_MED, STALKER_BEAM_HIGH, };
//Animation events
#define STALKER_AE_MELEE_HIT 1
ConVar sk_stalker_health( "sk_stalker_health","0"); ConVar sk_stalker_melee_dmg( "sk_stalker_melee_dmg","0");
extern void SpawnBlood(Vector vecSpot, const Vector &vAttackDir, int bloodColor, float flDamage);
LINK_ENTITY_TO_CLASS( npc_stalker, CNPC_Stalker );
float g_StalkerBeamThinkTime = 0.0; //0.025;
//=========================================================
// Private activities.
//=========================================================
static int ACT_STALKER_WORK = 0;
//=========================================================
// Stalker schedules
//=========================================================
enum { SCHED_STALKER_CHASE_ENEMY = LAST_SHARED_SCHEDULE, SCHED_STALKER_RANGE_ATTACK, SCHED_STALKER_ACQUIRE_PLAYER, SCHED_STALKER_PATROL, };
//=========================================================
// Stalker Tasks
//=========================================================
enum { TASK_STALKER_ZIGZAG = LAST_SHARED_TASK, TASK_STALKER_SCREAM, };
// -----------------------------------------------
// > Squad slots
// -----------------------------------------------
enum SquadSlot_T { SQUAD_SLOT_CHASE_ENEMY_1 = LAST_SHARED_SQUADSLOT, SQUAD_SLOT_CHASE_ENEMY_2, };
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CNPC_Stalker )
DEFINE_KEYFIELD( m_eBeamPower, FIELD_INTEGER, "BeamPower" ), DEFINE_FIELD( m_vLaserDir, FIELD_VECTOR), DEFINE_FIELD( m_vLaserTargetPos, FIELD_POSITION_VECTOR), DEFINE_FIELD( m_fBeamEndTime, FIELD_FLOAT), DEFINE_FIELD( m_fBeamRechargeTime, FIELD_FLOAT), DEFINE_FIELD( m_fNextDamageTime, FIELD_FLOAT), DEFINE_FIELD( m_bPlayingHitWall, FIELD_FLOAT), DEFINE_FIELD( m_bPlayingHitFlesh, FIELD_FLOAT), DEFINE_FIELD( m_pBeam, FIELD_CLASSPTR), DEFINE_FIELD( m_pLightGlow, FIELD_CLASSPTR), DEFINE_FIELD( m_flNextNPCThink, FIELD_FLOAT), DEFINE_FIELD( m_vLaserCurPos, FIELD_POSITION_VECTOR), DEFINE_FIELD( m_flNextAttackSoundTime, FIELD_TIME ), DEFINE_FIELD( m_flNextBreatheSoundTime, FIELD_TIME ), DEFINE_FIELD( m_flNextScrambleSoundTime, FIELD_TIME ), DEFINE_FIELD( m_nextSmokeTime, FIELD_TIME ), DEFINE_FIELD( m_iPlayerAggression, FIELD_INTEGER ), DEFINE_FIELD( m_flNextScreamTime, FIELD_TIME ),
// Function Pointers
DEFINE_THINKFUNC( StalkerThink ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_Stalker::OnTakeDamage_Alive( const CTakeDamageInfo &inputInfo ) { CTakeDamageInfo info = inputInfo;
// --------------------------------------------
// Don't take a lot of damage from Vortigaunt
// --------------------------------------------
if (info.GetAttacker()->Classify() == CLASS_VORTIGAUNT) { info.ScaleDamage( 0.25 ); }
int ret = BaseClass::OnTakeDamage_Alive( info );
// If player shot me make sure I'm mad at him even if I wasn't earlier
if ( (info.GetAttacker()->GetFlags() & FL_CLIENT) ) { AddClassRelationship( CLASS_PLAYER, D_HT, 0 ); } return ret; }
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CNPC_Stalker::MaxYawSpeed( void ) { #ifdef HL2_EPISODIC
return 10.0f; #else
switch( GetActivity() ) { case ACT_TURN_LEFT: case ACT_TURN_RIGHT: return 160; break; case ACT_RUN: case ACT_RUN_HURT: return 280; break; default: return 160; break; } #endif
}
//-----------------------------------------------------------------------------
// Purpose:
//
//
// Output : int
//-----------------------------------------------------------------------------
Class_T CNPC_Stalker::Classify( void ) { return CLASS_STALKER; }
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CNPC_Stalker::PrescheduleThink() { if (gpGlobals->curtime > m_flNextBreatheSoundTime) { EmitSound( "NPC_Stalker.Ambient01" ); m_flNextBreatheSoundTime = gpGlobals->curtime + 3.0 + random->RandomFloat( 0.0, 5.0 ); } }
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CNPC_Stalker::IsValidEnemy( CBaseEntity *pEnemy ) { Class_T enemyClass = pEnemy->Classify();
if( enemyClass == CLASS_PLAYER || enemyClass == CLASS_PLAYER_ALLY || enemyClass == CLASS_PLAYER_ALLY_VITAL ) { // Don't get angry at these folks unless provoked.
if( m_iPlayerAggression < STALKER_PLAYER_AGGRESSION ) { return false; } }
if( enemyClass == CLASS_BULLSEYE && pEnemy->GetParent() ) { // This bullseye is in heirarchy with something. If that
// something is held by the physcannon, this bullseye is
// NOT a valid enemy.
IPhysicsObject *pPhys = pEnemy->GetParent()->VPhysicsGetObject(); if( pPhys && (pPhys->GetGameFlags() & FVPHYSICS_PLAYER_HELD) ) { return false; } }
if( GetEnemy() && HasCondition(COND_SEE_ENEMY) ) { // Short attention span. If I have an enemy, stick with it.
if( GetEnemy() != pEnemy ) { return false; } }
if( IsStrategySlotRangeOccupied( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) && !HasStrategySlotRange( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) ) { return false; }
if( !FVisible(pEnemy) ) { // Don't take an enemy you can't see. Since stalkers move way too slowly to
// establish line of fire, usually an enemy acquired by means other than
// the Stalker's own eyesight will always get away while the stalker plods
// slowly to their last known position. So don't take enemies you can't see.
return false; }
return BaseClass::IsValidEnemy(pEnemy); }
//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
void CNPC_Stalker::Spawn( void ) { Precache( );
SetModel( "models/stalker.mdl" ); SetHullType(HULL_HUMAN); SetHullSizeNormal();
SetSolid( SOLID_BBOX ); AddSolidFlags( FSOLID_NOT_STANDABLE ); SetMoveType( MOVETYPE_STEP ); m_bloodColor = DONT_BLEED; m_iHealth = sk_stalker_health.GetFloat(); m_flFieldOfView = 0.1;// indicates the width of this NPC's forward view cone ( as a dotproduct result )
m_NPCState = NPC_STATE_NONE; CapabilitiesAdd( bits_CAP_SQUAD | bits_CAP_MOVE_GROUND ); CapabilitiesAdd( bits_CAP_INNATE_RANGE_ATTACK1);
m_flNextAttackSoundTime = 0; m_flNextBreatheSoundTime = gpGlobals->curtime + random->RandomFloat( 0.0, 10.0 ); m_flNextScrambleSoundTime = 0; m_nextSmokeTime = 0; m_bPlayingHitWall = false; m_bPlayingHitFlesh = false;
m_fBeamEndTime = 0; m_fBeamRechargeTime = 0; m_fNextDamageTime = 0;
NPCInit();
m_flDistTooFar = MAX_STALKER_FIRE_RANGE;
m_iPlayerAggression = 0;
GetSenses()->SetDistLook(MAX_STALKER_FIRE_RANGE - 1); }
//-----------------------------------------------------------------------------
// Purpose:
//
//
//-----------------------------------------------------------------------------
void CNPC_Stalker::Precache( void ) { PrecacheModel("models/stalker.mdl"); PrecacheModel("sprites/laser.vmt");
PrecacheModel("sprites/redglow1.vmt"); PrecacheModel("sprites/orangeglow1.vmt"); PrecacheModel("sprites/yellowglow1.vmt");
PrecacheScriptSound( "NPC_Stalker.BurnFlesh" ); PrecacheScriptSound( "NPC_Stalker.BurnWall" ); PrecacheScriptSound( "NPC_Stalker.FootstepLeft" ); PrecacheScriptSound( "NPC_Stalker.FootstepRight" ); PrecacheScriptSound( "NPC_Stalker.Hit" ); PrecacheScriptSound( "NPC_Stalker.Ambient01" ); PrecacheScriptSound( "NPC_Stalker.Scream" ); PrecacheScriptSound( "NPC_Stalker.Pain" ); PrecacheScriptSound( "NPC_Stalker.Die" );
BaseClass::Precache(); }
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CNPC_Stalker::CreateBehaviors() { AddBehavior( &m_ActBusyBehavior );
return BaseClass::CreateBehaviors(); }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_Stalker::IdleSound ( void ) { }
void CNPC_Stalker::OnScheduleChange() { KillAttackBeam();
BaseClass::OnScheduleChange(); } //-----------------------------------------------------------------------------
// Purpose:
// Input : pInflictor -
// pAttacker -
// flDamage -
// bitsDamageType -
//-----------------------------------------------------------------------------
void CNPC_Stalker::Event_Killed( const CTakeDamageInfo &info ) { if( IsInSquad() && info.GetAttacker()->IsPlayer() ) { AISquadIter_t iter; for ( CAI_BaseNPC *pSquadMember = GetSquad()->GetFirstMember( &iter ); pSquadMember; pSquadMember = GetSquad()->GetNextMember( &iter ) ) { if ( pSquadMember->IsAlive() && pSquadMember != this ) { CNPC_Stalker *pStalker = dynamic_cast <CNPC_Stalker*>(pSquadMember);
if( pStalker && pStalker->FVisible(info.GetAttacker()) ) { pStalker->m_iPlayerAggression++; } } } }
KillAttackBeam(); BaseClass::Event_Killed( info ); }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_Stalker::DeathSound( const CTakeDamageInfo &info ) { EmitSound( "NPC_Stalker.Die" ); };
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_Stalker::PainSound( const CTakeDamageInfo &info ) { EmitSound( "NPC_Stalker.Pain" ); m_flNextScrambleSoundTime = gpGlobals->curtime + 1.5; m_flNextBreatheSoundTime = gpGlobals->curtime + 1.5; m_flNextAttackSoundTime = gpGlobals->curtime + 1.5; };
//-----------------------------------------------------------------------------
// Purpose: Translates squad slot positions into schedules
// Input :
// Output :
//-----------------------------------------------------------------------------
#if 0
// @TODO (toml 07-18-03): this function is never called. Presumably what it is trying to do still needs to be done...
int CNPC_Stalker::GetSlotSchedule(int slotID) { switch (slotID) {
case SQUAD_SLOT_CHASE_ENEMY_1: case SQUAD_SLOT_CHASE_ENEMY_2: return SCHED_STALKER_CHASE_ENEMY; break; } return SCHED_NONE; } #endif
void CNPC_Stalker::UpdateAttackBeam( void ) { CBaseEntity *pEnemy = GetEnemy(); // If not burning at a target
if (pEnemy) { if (gpGlobals->curtime > m_fBeamEndTime) { TaskComplete(); } else { Vector enemyLKP = GetEnemyLKP(); m_vLaserTargetPos = enemyLKP + pEnemy->GetViewOffset();
// Face my enemy
GetMotor()->SetIdealYawToTargetAndUpdate( enemyLKP );
// ---------------------------------------------
// Get beam end point
// ---------------------------------------------
Vector vecSrc = LaserStartPosition(GetAbsOrigin()); Vector targetDir = m_vLaserTargetPos - vecSrc; VectorNormalize(targetDir); // --------------------------------------------------------
// If beam position and laser dir are way off, end attack
// --------------------------------------------------------
if ( DotProduct(targetDir,m_vLaserDir) < 0.5 ) { TaskComplete(); return; }
trace_t tr; AI_TraceLine( vecSrc, vecSrc + m_vLaserDir * MAX_STALKER_FIRE_RANGE, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); // ---------------------------------------------
// If beam not long enough, stop attacking
// ---------------------------------------------
if (tr.fraction == 1.0) { TaskComplete(); return; }
CSoundEnt::InsertSound(SOUND_DANGER, tr.endpos, 60, 0.025, this); } } else { TaskFail(FAIL_NO_ENEMY); } }
//=========================================================
// start task
//=========================================================
void CNPC_Stalker::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_STALKER_SCREAM: { if( gpGlobals->curtime > m_flNextScreamTime ) { EmitSound( "NPC_Stalker.Scream" ); m_flNextScreamTime = gpGlobals->curtime + random->RandomFloat( 10.0, 15.0 ); }
TaskComplete(); }
case TASK_ANNOUNCE_ATTACK: { // If enemy isn't facing me and I haven't attacked in a while
// annouce my attack before I start wailing away
CBaseCombatCharacter *pBCC = GetEnemyCombatCharacterPointer();
if (pBCC && (!pBCC->FInViewCone ( this )) && (gpGlobals->curtime - m_flLastAttackTime > 1.0) ) { m_flLastAttackTime = gpGlobals->curtime;
// Always play this sound
EmitSound( "NPC_Stalker.Scream" ); m_flNextScrambleSoundTime = gpGlobals->curtime + 2; m_flNextBreatheSoundTime = gpGlobals->curtime + 2;
// Wait two seconds
SetWait( 2.0 ); SetActivity(ACT_IDLE); } break; } case TASK_STALKER_ZIGZAG: break; case TASK_RANGE_ATTACK1: { CBaseEntity *pEnemy = GetEnemy(); if (pEnemy) { m_vLaserTargetPos = GetEnemyLKP() + pEnemy->GetViewOffset();
// Never hit target on first try
Vector missPos = m_vLaserTargetPos; if( pEnemy->Classify() == CLASS_BULLSEYE && hl2_episodic.GetBool() ) { missPos.x += 60 + 120*random->RandomInt(-1,1); missPos.y += 60 + 120*random->RandomInt(-1,1); } else { missPos.x += 80*random->RandomInt(-1,1); missPos.y += 80*random->RandomInt(-1,1); }
// ----------------------------------------------------------------------
// If target is facing me and not running towards me shoot below his feet
// so he can see the laser coming
// ----------------------------------------------------------------------
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter(pEnemy); if (pBCC) { Vector targetToMe = (pBCC->GetAbsOrigin() - GetAbsOrigin()); Vector vBCCFacing = pBCC->BodyDirection2D( ); if ((DotProduct(vBCCFacing,targetToMe) < 0) && (pBCC->GetSmoothedVelocity().Length() < 50)) { missPos.z -= 150; } // --------------------------------------------------------
// If facing away or running towards laser,
// shoot above target's head
// --------------------------------------------------------
else { missPos.z += 60; } } m_vLaserDir = missPos - LaserStartPosition(GetAbsOrigin()); VectorNormalize(m_vLaserDir); } else { TaskFail(FAIL_NO_ENEMY); return; }
StartAttackBeam(); SetActivity(ACT_RANGE_ATTACK1); break; } case TASK_GET_PATH_TO_ENEMY_LOS: { if ( GetEnemy() != NULL ) { BaseClass:: StartTask( pTask ); return; }
Vector posLos;
if (GetTacticalServices()->FindLos(m_vLaserCurPos, m_vLaserCurPos, MIN_STALKER_FIRE_RANGE, MAX_STALKER_FIRE_RANGE, 1.0, &posLos)) { AI_NavGoal_t goal( posLos, ACT_RUN, AIN_HULL_TOLERANCE ); GetNavigator()->SetGoal( goal ); } else { TaskFail(FAIL_NO_SHOOT); } break; } case TASK_FACE_ENEMY: { if ( GetEnemy() != NULL ) { BaseClass:: StartTask( pTask ); return; } GetMotor()->SetIdealYawToTarget( m_vLaserCurPos ); break; } default: BaseClass:: StartTask( pTask ); break; } }
//=========================================================
// RunTask
//=========================================================
void CNPC_Stalker::RunTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_ANNOUNCE_ATTACK: { // Stop waiting if enemy facing me or lost enemy
CBaseCombatCharacter* pBCC = GetEnemyCombatCharacterPointer(); if (!pBCC || pBCC->FInViewCone( this )) { TaskComplete(); }
if ( IsWaitFinished() ) { TaskComplete(); } break; }
case TASK_STALKER_ZIGZAG : {
if (GetNavigator()->GetGoalType() == GOALTYPE_NONE) { TaskComplete(); GetNavigator()->StopMoving(); // Stop moving
} else if (!GetNavigator()->IsGoalActive()) { SetIdealActivity( GetStoppedActivity() ); } else if (ValidateNavGoal()) { SetIdealActivity( GetNavigator()->GetMovementActivity() ); AddZigZagToPath(); } break; } case TASK_RANGE_ATTACK1: UpdateAttackBeam(); if ( !TaskIsRunning() || HasCondition( COND_TASK_FAILED )) { KillAttackBeam(); } break;
case TASK_FACE_ENEMY: { if ( GetEnemy() != NULL ) { BaseClass:: RunTask( pTask ); return; } GetMotor()->SetIdealYawToTargetAndUpdate( m_vLaserCurPos );
if ( FacingIdeal() ) { TaskComplete(); } break; } default: { BaseClass::RunTask( pTask ); break; } } }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_Stalker::SelectSchedule( void ) { if ( BehaviorSelectSchedule() ) { return BaseClass::SelectSchedule(); }
switch ( m_NPCState ) { case NPC_STATE_IDLE: case NPC_STATE_ALERT: { if( HasCondition(COND_IN_PVS) ) { return SCHED_STALKER_PATROL; }
return SCHED_IDLE_STAND;
break; }
case NPC_STATE_COMBAT: { // -----------
// new enemy
// -----------
if( HasCondition( COND_NEW_ENEMY ) ) { if( GetEnemy()->IsPlayer() ) { return SCHED_STALKER_ACQUIRE_PLAYER; } }
if( HasCondition( COND_CAN_RANGE_ATTACK1 ) ) { if( OccupyStrategySlotRange(SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2) ) { return SCHED_RANGE_ATTACK1; } else { return SCHED_STALKER_PATROL; } }
if( !HasCondition(COND_SEE_ENEMY) ) { return SCHED_STALKER_PATROL; }
return SCHED_COMBAT_FACE;
break; } }
// no special cases here, call the base class
return BaseClass::SelectSchedule(); }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_Stalker::TranslateSchedule( int scheduleType ) { switch( scheduleType ) { case SCHED_RANGE_ATTACK1: { return SCHED_STALKER_RANGE_ATTACK; } case SCHED_FAIL_ESTABLISH_LINE_OF_FIRE: { return SCHED_COMBAT_STAND; break; } case SCHED_FAIL_TAKE_COVER: { return SCHED_RUN_RANDOM; break; } }
return BaseClass::TranslateSchedule( scheduleType ); }
//------------------------------------------------------------------------------
// Purpose : Returns position of laser for any given position of the staler
// Input :
// Output :
//------------------------------------------------------------------------------
Vector CNPC_Stalker::LaserStartPosition(Vector vStalkerPos) { // Get attachment position
Vector vAttachPos; GetAttachment(STALKER_LASER_ATTACHMENT,vAttachPos);
// Now convert to vStalkerPos
vAttachPos = vAttachPos - GetAbsOrigin() + vStalkerPos; return vAttachPos; }
//------------------------------------------------------------------------------
// Purpose : Calculate position of beam
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_Stalker::CalcBeamPosition(void) { Vector targetDir = m_vLaserTargetPos - LaserStartPosition(GetAbsOrigin()); VectorNormalize(targetDir);
// ---------------------------------------
// Otherwise if burning towards an enemy
// ---------------------------------------
if ( GetEnemy() ) { // ---------------------------------------
// Integrate towards target position
// ---------------------------------------
float iRate = 0.95;
if( GetEnemy()->Classify() == CLASS_BULLSEYE ) { // Seek bullseyes faster
iRate = 0.8; }
m_vLaserDir.x = (iRate * m_vLaserDir.x + (1-iRate) * targetDir.x); m_vLaserDir.y = (iRate * m_vLaserDir.y + (1-iRate) * targetDir.y); m_vLaserDir.z = (iRate * m_vLaserDir.z + (1-iRate) * targetDir.z); VectorNormalize( m_vLaserDir );
// -----------------------------------------
// Add time-coherent noise to the position
// Must be scaled with distance
// -----------------------------------------
float fTargetDist = (GetAbsOrigin() - m_vLaserTargetPos).Length(); float noiseScale = atan(0.2/fTargetDist); float m_fNoiseModX = 5; float m_fNoiseModY = 5; float m_fNoiseModZ = 5;
m_vLaserDir.x += 5*noiseScale*sin(m_fNoiseModX * gpGlobals->curtime + m_fNoiseModX); m_vLaserDir.y += 5*noiseScale*sin(m_fNoiseModY * gpGlobals->curtime + m_fNoiseModY); m_vLaserDir.z += 5*noiseScale*sin(m_fNoiseModZ * gpGlobals->curtime + m_fNoiseModZ); } }
void CNPC_Stalker::StartAttackBeam( void ) { if ( m_fBeamEndTime > gpGlobals->curtime || m_fBeamRechargeTime > gpGlobals->curtime ) { // UNDONE: Debug this and fix!?!?!
m_fBeamRechargeTime = gpGlobals->curtime; } // ---------------------------------------------
// If I don't have a beam yet, create one
// ---------------------------------------------
// UNDONE: Why would I ever have a beam already?!?!?!
if (!m_pBeam) { Vector vecSrc = LaserStartPosition(GetAbsOrigin()); trace_t tr; AI_TraceLine ( vecSrc, vecSrc + m_vLaserDir * MAX_STALKER_FIRE_RANGE, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); if ( tr.fraction >= 1.0 ) { // too far
TaskComplete(); return; }
m_pBeam = CBeam::BeamCreate( "sprites/laser.vmt", 2.0 ); m_pBeam->PointEntInit( tr.endpos, this ); m_pBeam->SetEndAttachment( STALKER_LASER_ATTACHMENT ); m_pBeam->SetBrightness( 255 ); m_pBeam->SetNoise( 0 );
switch (m_eBeamPower) { case STALKER_BEAM_LOW: m_pBeam->SetColor( 255, 0, 0 ); m_pLightGlow = CSprite::SpriteCreate( "sprites/redglow1.vmt", GetAbsOrigin(), FALSE ); break; case STALKER_BEAM_MED: m_pBeam->SetColor( 255, 50, 0 ); m_pLightGlow = CSprite::SpriteCreate( "sprites/orangeglow1.vmt", GetAbsOrigin(), FALSE ); break; case STALKER_BEAM_HIGH: m_pBeam->SetColor( 255, 150, 0 ); m_pLightGlow = CSprite::SpriteCreate( "sprites/yellowglow1.vmt", GetAbsOrigin(), FALSE ); break; }
// ----------------------------
// Light myself in a red glow
// ----------------------------
m_pLightGlow->SetTransparency( kRenderGlow, 255, 200, 200, 0, kRenderFxNoDissipation ); m_pLightGlow->SetAttachment( this, 1 ); m_pLightGlow->SetBrightness( 255 ); m_pLightGlow->SetScale( 0.65 );
#if 0
CBaseEntity *pEnemy = GetEnemy(); // --------------------------------------------------------
// Play start up sound - client should always hear this!
// --------------------------------------------------------
if (pEnemy != NULL && (pEnemy->IsPlayer()) ) { EmitAmbientSound( 0, pEnemy->GetAbsOrigin(), "NPC_Stalker.AmbientLaserStart" ); } else { EmitAmbientSound( 0, GetAbsOrigin(), "NPC_Stalker.AmbientLaserStart" ); } #endif
}
SetThink( &CNPC_Stalker::StalkerThink );
m_flNextNPCThink = GetNextThink(); SetNextThink( gpGlobals->curtime + g_StalkerBeamThinkTime ); m_fBeamEndTime = gpGlobals->curtime + STALKER_LASER_DURATION; }
//------------------------------------------------------------------------------
// Purpose : Update beam more often then regular NPC think so it doesn't
// move so jumpily over the ground
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_Stalker::StalkerThink(void) { DrawAttackBeam(); if (gpGlobals->curtime >= m_flNextNPCThink) { NPCThink(); m_flNextNPCThink = GetNextThink(); }
if ( m_pBeam ) { SetNextThink( gpGlobals->curtime + g_StalkerBeamThinkTime ); // sanity check?!
const Task_t *pTask = GetTask(); if ( !pTask || pTask->iTask != TASK_RANGE_ATTACK1 || !TaskIsRunning() ) { KillAttackBeam(); } } else { DevMsg( 2, "In StalkerThink() but no stalker beam found?\n" ); SetNextThink( m_flNextNPCThink ); } }
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void CNPC_Stalker::NotifyDeadFriend( CBaseEntity *pFriend ) { BaseClass::NotifyDeadFriend(pFriend); }
void CNPC_Stalker::DoSmokeEffect( const Vector &position ) { if ( gpGlobals->curtime > m_nextSmokeTime ) { m_nextSmokeTime = gpGlobals->curtime + 0.5; UTIL_Smoke(position, random->RandomInt(5, 10), 10); } }
//------------------------------------------------------------------------------
// Purpose : Draw attack beam and do damage / decals
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_Stalker::DrawAttackBeam(void) { if (!m_pBeam) return;
// ---------------------------------------------
// Get beam end point
// ---------------------------------------------
Vector vecSrc = LaserStartPosition(GetAbsOrigin()); trace_t tr; AI_TraceLine( vecSrc, vecSrc + m_vLaserDir * MAX_STALKER_FIRE_RANGE, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
CalcBeamPosition();
bool bInWater = (UTIL_PointContents ( tr.endpos ) & MASK_WATER)?true:false; // ---------------------------------------------
// Update the beam position
// ---------------------------------------------
m_pBeam->SetStartPos( tr.endpos ); m_pBeam->RelinkBeam();
Vector vAttachPos; GetAttachment(STALKER_LASER_ATTACHMENT,vAttachPos);
Vector vecAimDir = tr.endpos - vAttachPos; VectorNormalize( vecAimDir );
SetAim( vecAimDir );
// --------------------------------------------
// Play burn sounds
// --------------------------------------------
CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( tr.m_pEnt ); if (pBCC) { if (gpGlobals->curtime > m_fNextDamageTime) { ClearMultiDamage();
float damage = 0.0; switch (m_eBeamPower) { case STALKER_BEAM_LOW: damage = 1; break; case STALKER_BEAM_MED: damage = 3; break; case STALKER_BEAM_HIGH: damage = 10; break; }
CTakeDamageInfo info( this, this, damage, DMG_SHOCK ); CalculateMeleeDamageForce( &info, m_vLaserDir, tr.endpos ); pBCC->DispatchTraceAttack( info, m_vLaserDir, &tr ); ApplyMultiDamage(); m_fNextDamageTime = gpGlobals->curtime + 0.1; } if (pBCC->Classify()!=CLASS_BULLSEYE) { if (!m_bPlayingHitFlesh) { CPASAttenuationFilter filter( m_pBeam,"NPC_Stalker.BurnFlesh" ); filter.MakeReliable();
EmitSound( filter, m_pBeam->entindex(),"NPC_Stalker.BurnFlesh" ); m_bPlayingHitFlesh = true; } if (m_bPlayingHitWall) { StopSound( m_pBeam->entindex(), "NPC_Stalker.BurnWall" ); m_bPlayingHitWall = false; }
tr.endpos.z -= 24.0f; if (!bInWater) { DoSmokeEffect(tr.endpos + tr.plane.normal * 8); } } } if (!pBCC || pBCC->Classify()==CLASS_BULLSEYE) { if (!m_bPlayingHitWall) { CPASAttenuationFilter filter( m_pBeam, "NPC_Stalker.BurnWall" ); filter.MakeReliable();
EmitSound( filter, m_pBeam->entindex(), "NPC_Stalker.BurnWall" ); m_bPlayingHitWall = true; } if (m_bPlayingHitFlesh) { StopSound(m_pBeam->entindex(), "NPC_Stalker.BurnFlesh" ); m_bPlayingHitFlesh = false; }
UTIL_DecalTrace( &tr, "RedGlowFade"); UTIL_DecalTrace( &tr, "FadingScorch" ); tr.endpos.z -= 24.0f; if (!bInWater) { DoSmokeEffect(tr.endpos + tr.plane.normal * 8); } }
if (bInWater) { UTIL_Bubbles(tr.endpos-Vector(3,3,3),tr.endpos+Vector(3,3,3),10); }
/*
CBroadcastRecipientFilter filter; TE_DynamicLight( filter, 0.0, EyePosition(), 255, 0, 0, 5, 0.2, 0 ); */ }
//------------------------------------------------------------------------------
// Purpose : Draw attack beam and do damage / decals
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_Stalker::KillAttackBeam(void) { if ( !m_pBeam ) return;
// Kill sound
StopSound(m_pBeam->entindex(), "NPC_Stalker.BurnWall" ); StopSound(m_pBeam->entindex(), "NPC_Stalker.BurnFlesh" );
UTIL_Remove( m_pLightGlow ); UTIL_Remove( m_pBeam); m_pBeam = NULL; m_bPlayingHitWall = false; m_bPlayingHitFlesh = false;
SetThink(&CNPC_Stalker::CallNPCThink); if ( m_flNextNPCThink > gpGlobals->curtime ) { SetNextThink( m_flNextNPCThink ); }
// Beam has to recharge
m_fBeamRechargeTime = gpGlobals->curtime + STALKER_LASER_RECHARGE;
ClearCondition( COND_CAN_RANGE_ATTACK1 );
RelaxAim(); }
//-----------------------------------------------------------------------------
// Purpose: Override so can handle LOS to m_pScriptedTarget
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CNPC_Stalker::InnateWeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions ) { // --------------------
// Check for occlusion
// --------------------
// Base class version assumes innate weapon position is at eye level
Vector barrelPos = LaserStartPosition(ownerPos); trace_t tr; AI_TraceLine( barrelPos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
if ( tr.fraction == 1.0 ) { return true; }
CBaseEntity *pBE = tr.m_pEnt; CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pBE ); if ( pBE == GetEnemy() ) { return true; } else if (pBCC) { if (IRelationType( pBCC ) == D_HT) { return true; } else if (bSetConditions) { SetCondition(COND_WEAPON_BLOCKED_BY_FRIEND); } } else if (bSetConditions) { SetCondition(COND_WEAPON_SIGHT_OCCLUDED); SetEnemyOccluder(pBE); }
return false; }
//-----------------------------------------------------------------------------
// Purpose: For innate melee attack
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_Stalker::MeleeAttack1Conditions ( float flDot, float flDist ) { if (flDist > MIN_STALKER_FIRE_RANGE) { return COND_TOO_FAR_TO_ATTACK; } else if (flDot < 0.7) { return COND_NOT_FACING_ATTACK; } return COND_CAN_MELEE_ATTACK1; }
//-----------------------------------------------------------------------------
// Purpose: For innate range attack
// Input :
// Output :
//-----------------------------------------------------------------------------
int CNPC_Stalker::RangeAttack1Conditions( float flDot, float flDist ) { if (gpGlobals->curtime < m_fBeamRechargeTime ) { return COND_NONE; }
if( IsStrategySlotRangeOccupied( SQUAD_SLOT_ATTACK1, SQUAD_SLOT_ATTACK2 ) ) { // Couldn't attack if I wanted to.
return COND_NONE; }
if (flDist <= MIN_STALKER_FIRE_RANGE) { return COND_TOO_CLOSE_TO_ATTACK; } else if (flDist > (MAX_STALKER_FIRE_RANGE * 0.66f) ) { return COND_TOO_FAR_TO_ATTACK; } else if (flDot < 0.7) { return COND_NOT_FACING_ATTACK; } return COND_CAN_RANGE_ATTACK1; }
//-----------------------------------------------------------------------------
// Purpose: Catch stalker specific messages
// Input :
// Output :
//-----------------------------------------------------------------------------
void CNPC_Stalker::HandleAnimEvent( animevent_t *pEvent ) { switch( pEvent->event ) { case NPC_EVENT_LEFTFOOT: { EmitSound( "NPC_Stalker.FootstepLeft", pEvent->eventtime ); } break; case NPC_EVENT_RIGHTFOOT: { EmitSound( "NPC_Stalker.FootstepRight", pEvent->eventtime ); } break;
case STALKER_AE_MELEE_HIT: { CBaseEntity *pHurt;
pHurt = CheckTraceHullAttack( 32, Vector(-16,-16,-16), Vector(16,16,16), sk_stalker_melee_dmg.GetFloat(), DMG_SLASH );
if ( pHurt ) { if ( pHurt->GetFlags() & (FL_NPC|FL_CLIENT) ) { pHurt->ViewPunch( QAngle( 5, 0, random->RandomInt(-10,10)) ); } // Spawn some extra blood if we hit a BCC
CBaseCombatCharacter* pBCC = ToBaseCombatCharacter( pHurt ); if (pBCC) { SpawnBlood(pBCC->EyePosition(), g_vecAttackDir, pBCC->BloodColor(), sk_stalker_melee_dmg.GetFloat()); }
// Play a attack hit sound
EmitSound( "NPC_Stalker.Hit" ); } break; } default: BaseClass::HandleAnimEvent( pEvent ); break; } }
//-----------------------------------------------------------------------------
// Purpose: Tells use whether or not the NPC cares about a given type of hint node.
// Input : sHint -
// Output : TRUE if the NPC is interested in this hint type, FALSE if not.
//-----------------------------------------------------------------------------
bool CNPC_Stalker::FValidateHintType(CAI_Hint *pHint) { return(pHint->HintType() == HINT_WORLD_WORK_POSITION); }
//-----------------------------------------------------------------------------
// Purpose: Override in subclasses to associate specific hint types
// with activities
// Input :
// Output :
//-----------------------------------------------------------------------------
Activity CNPC_Stalker::GetHintActivity( short sHintType, Activity HintsActivity ) { if (sHintType == HINT_WORLD_WORK_POSITION) { return ( Activity )ACT_STALKER_WORK; }
return BaseClass::GetHintActivity( sHintType, HintsActivity ); }
//-----------------------------------------------------------------------------
// Purpose: Override in subclasses to give specific hint types delays
// before they can be used again
// Input :
// Output :
//-----------------------------------------------------------------------------
float CNPC_Stalker::GetHintDelay( short sHintType ) { if (sHintType == HINT_WORLD_WORK_POSITION) { return 2.0; } return 0; }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
#define ZIG_ZAG_SIZE 3600
void CNPC_Stalker::AddZigZagToPath(void) { // If already on a detour don't add a zigzag
if (GetNavigator()->GetCurWaypointFlags() & bits_WP_TO_DETOUR) { return; }
// If enemy isn't facing me or occluded, don't add a zigzag
if (HasCondition(COND_ENEMY_OCCLUDED) || !HasCondition ( COND_ENEMY_FACING_ME )) { return; }
Vector waypointPos = GetNavigator()->GetCurWaypointPos(); Vector waypointDir = (waypointPos - GetAbsOrigin());
// If the distance to the next node is greater than ZIG_ZAG_SIZE
// then add a random zig/zag to the path
if (waypointDir.LengthSqr() > ZIG_ZAG_SIZE) { // Pick a random distance for the zigzag (less that sqrt(ZIG_ZAG_SIZE)
float distance = random->RandomFloat( 30, 60 );
// Get me a vector orthogonal to the direction of motion
VectorNormalize( waypointDir ); Vector vDirUp(0,0,1); Vector vDir; CrossProduct( waypointDir, vDirUp, vDir);
// Pick a random direction (left/right) for the zigzag
if (random->RandomInt(0,1)) { vDir = -1 * vDir; }
// Get zigzag position in direction of target waypoint
Vector zigZagPos = GetAbsOrigin() + waypointDir * 60;
// Now offset
zigZagPos = zigZagPos + (vDir * distance);
// Now make sure that we can still get to the zigzag position and the waypoint
AIMoveTrace_t moveTrace1, moveTrace2; GetMoveProbe()->MoveLimit( NAV_GROUND, GetAbsOrigin(), zigZagPos, MASK_NPCSOLID, NULL, &moveTrace1); GetMoveProbe()->MoveLimit( NAV_GROUND, zigZagPos, waypointPos, MASK_NPCSOLID, NULL, &moveTrace2); if ( !IsMoveBlocked( moveTrace1 ) && !IsMoveBlocked( moveTrace2 ) ) { GetNavigator()->PrependWaypoint( zigZagPos, NAV_GROUND, bits_WP_TO_DETOUR ); } } }
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
CNPC_Stalker::CNPC_Stalker(void) { #ifdef _DEBUG
m_vLaserDir.Init(); m_vLaserTargetPos.Init(); m_vLaserCurPos.Init(); #endif
}
//------------------------------------------------------------------------------
//
// Schedules
//
//------------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( npc_stalker, CNPC_Stalker )
DECLARE_TASK(TASK_STALKER_ZIGZAG) DECLARE_TASK(TASK_STALKER_SCREAM)
DECLARE_ACTIVITY(ACT_STALKER_WORK)
DECLARE_SQUADSLOT(SQUAD_SLOT_CHASE_ENEMY_1) DECLARE_SQUADSLOT(SQUAD_SLOT_CHASE_ENEMY_2)
//=========================================================
// > SCHED_STALKER_RANGE_ATTACK
//=========================================================
DEFINE_SCHEDULE ( SCHED_STALKER_RANGE_ATTACK,
" Tasks" " TASK_STOP_MOVING 0" " TASK_FACE_ENEMY 0" " TASK_RANGE_ATTACK1 0" "" " Interrupts" " COND_CAN_MELEE_ATTACK1" " COND_HEAVY_DAMAGE" " COND_REPEATED_DAMAGE" " COND_HEAR_DANGER" " COND_NEW_ENEMY" " COND_ENEMY_DEAD" " COND_ENEMY_OCCLUDED" // Don't break on this. Keep shooting at last location
)
//=========================================================
// > SCHED_STALKER_CHASE_ENEMY
//=========================================================
DEFINE_SCHEDULE ( SCHED_STALKER_CHASE_ENEMY,
" Tasks" " TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_CHASE_ENEMY_FAILED" " TASK_SET_TOLERANCE_DISTANCE 24" " TASK_GET_PATH_TO_ENEMY 0" " TASK_RUN_PATH 0" " TASK_STALKER_ZIGZAG 0" "" " Interrupts" " COND_NEW_ENEMY" " COND_ENEMY_DEAD" " COND_CAN_RANGE_ATTACK1" " COND_CAN_MELEE_ATTACK1" " COND_CAN_RANGE_ATTACK2" " COND_CAN_MELEE_ATTACK2" " COND_TOO_CLOSE_TO_ATTACK" " COND_TASK_FAILED" " COND_HEAR_DANGER" )
DEFINE_SCHEDULE ( SCHED_STALKER_ACQUIRE_PLAYER,
" Tasks" " TASK_STOP_MOVING 0" " TASK_FACE_ENEMY 0" " TASK_WAIT_RANDOM 0.5" " TASK_STALKER_SCREAM 0" " TASK_WAIT 0.5" " TASK_WAIT_RANDOM 0.5" "" " Interrupts" )
DEFINE_SCHEDULE ( SCHED_STALKER_PATROL,
" Tasks" " TASK_STOP_MOVING 0" " TASK_WAIT 0.5"// This makes them look a bit more vigilant, instead of INSTANTLY patrolling after some other action.
" TASK_WAIT_RANDOM 0.5" " TASK_WANDER 18000600" " TASK_FACE_PATH 0" " TASK_WALK_PATH 0" " TASK_WAIT_FOR_MOVEMENT 0" " TASK_STOP_MOVING 0" " TASK_FACE_REASONABLE 0" " TASK_SET_SCHEDULE SCHEDULE:SCHED_STALKER_PATROL" "" " Interrupts" " COND_NEW_ENEMY" " COND_CAN_RANGE_ATTACK1" " COND_SEE_ENEMY" )
AI_END_CUSTOM_NPC()
|