mv
/
sqwarmed
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sqwarmed/sdk_src/game/server/swarm/asw_mortarbug.cpp

1031 lines
29 KiB
C++
Raw Blame History

#include "cbase.h"
#include "asw_mortarbug.h"
#include "te_effect_dispatch.h"
#include "npc_bullseye.h"
#include "npcevent.h"
#include "asw_marine.h"
#include "asw_parasite.h"
#include "soundenvelope.h"
#include "ai_memory.h"
#include "asw_gamerules.h"
#include "asw_weapon.h"
#include "asw_shareddefs.h"
#include "asw_weapon_assault_shotgun_shared.h"
#include "asw_mortarbug_shell_shared.h"
#include "particle_parse.h"
#include "ai_network.h"
#include "ai_networkmanager.h"
#include "ai_pathfinder.h"
#include "ai_link.h"
#include "asw_util_shared.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define ASW_MORTARBUG_MAX_ATTACK_DISTANCE 1500
LINK_ENTITY_TO_CLASS( asw_mortarbug, CASW_Mortarbug );
float CASW_Mortarbug::s_fNextSpawnSoundTime = 0;
float CASW_Mortarbug::s_fNextPainSoundTime = 0;
#define ASW_MORTARBUG_PROJECTILE "asw_mortarbug_shell"
BEGIN_DATADESC( CASW_Mortarbug )
DEFINE_FIELD( m_fLastFireTime, FIELD_TIME ),
DEFINE_FIELD( m_fLastTouchHurtTime, FIELD_TIME ),
DEFINE_FIELD( m_fGibTime, FIELD_TIME ),
DEFINE_FIELD( m_flIdleDelay, FIELD_TIME ),
DEFINE_FIELD( m_vecSaveSpitVelocity, FIELD_VECTOR ),
END_DATADESC()
ConVar asw_mortarbug_speedboost( "asw_mortarbug_speedboost", "1.0",FCVAR_CHEAT , "boost speed for the mortarbug" );
ConVar asw_mortarbug_touch_damage( "asw_mortarbug_touch_damage", "5",FCVAR_CHEAT , "Damage caused by mortarbug on touch" );
ConVar asw_mortarbug_spitspeed( "asw_mortarbug_spitspeed", "350", FCVAR_CHEAT, "Speed at which mortarbug grenade travels." );
ConVar asw_debug_mortarbug( "asw_debug_mortarbug", "0", FCVAR_NONE, "Display mortarbug debug info" );
ConVar asw_mortarbug_face_target("asw_mortarbug_face_target", "1", FCVAR_CHEAT, "Mortarbug faces his target when moving" );
extern ConVar sv_gravity;
extern ConVar asw_mortarbug_shell_gravity; // TODO: Replace with proper spit projectile's gravity
// Anim Events
int AE_MORTARBUG_CHARGE; // charging up to spit
int AE_MORTARBUG_LAUNCH; // actual launch of the projectile
// Activities
int ACT_MORTARBUG_SPIT;
CASW_Mortarbug::CASW_Mortarbug()
{
m_fLastFireTime = 0;
m_fLastTouchHurtTime = 0;
m_pszAlienModelName = SWARM_MORTARBUG_MODEL;
m_nAlienCollisionGroup = ASW_COLLISION_GROUP_ALIEN;
}
CASW_Mortarbug::~CASW_Mortarbug()
{
}
void CASW_Mortarbug::Spawn( void )
{
SetHullType(HULL_WIDE_SHORT);
BaseClass::Spawn();
SetHullType(HULL_WIDE_SHORT);
UTIL_SetSize(this, Vector(-23,-23,0), Vector(23,23,69));
m_iHealth = ASWGameRules()->ModifyAlienHealthBySkillLevel(350);
CapabilitiesAdd( bits_CAP_MOVE_GROUND | bits_CAP_INNATE_RANGE_ATTACK1 );
m_takedamage = DAMAGE_NO; // alien is invulnerable until she finds her first enemy
}
void CASW_Mortarbug::Precache( void )
{
PrecacheScriptSound( "ASW_MortarBug.Idle" );
PrecacheScriptSound( "ASW_MortarBug.Pain" );
PrecacheScriptSound( "ASW_MortarBug.Spit" );
PrecacheScriptSound( "ASW_MortarBug.OnFire" );
PrecacheScriptSound( "ASW_MortarBug.Death" );
PrecacheParticleSystem( "mortar_launch" );
UTIL_PrecacheOther( ASW_MORTARBUG_PROJECTILE );
BaseClass::Precache();
}
float CASW_Mortarbug::GetIdealSpeed() const
{
return asw_mortarbug_speedboost.GetFloat() * BaseClass::GetIdealSpeed() * m_flPlaybackRate;
}
float CASW_Mortarbug::GetIdealAccel( ) const
{
return GetIdealSpeed() * 1.5f;
}
float CASW_Mortarbug::MaxYawSpeed( void )
{
if ( m_bElectroStunned.Get() )
return 0.1f;
return 16.0f * asw_mortarbug_speedboost.GetFloat();
}
void CASW_Mortarbug::AlertSound()
{
EmitSound( "ASW_MortarBug.Idle" );
}
void CASW_Mortarbug::PainSound( const CTakeDamageInfo &info )
{
if (gpGlobals->curtime > m_fNextPainSound && gpGlobals->curtime > s_fNextPainSoundTime)
{
m_fNextPainSound = gpGlobals->curtime + 0.5f;
s_fNextPainSoundTime = gpGlobals->curtime + 1.0f;
EmitSound("ASW_MortarBug.Pain");
}
}
void CASW_Mortarbug::AttackSound()
{
if (gpGlobals->curtime > s_fNextSpawnSoundTime)
{
EmitSound("ASW_MortarBug.Spit");
s_fNextSpawnSoundTime = gpGlobals->curtime + 2.0f;
}
}
void CASW_Mortarbug::IdleSound()
{
EmitSound( "ASW_MortarBug.Idle" );
m_flIdleDelay = gpGlobals->curtime + 4.0f;
}
void CASW_Mortarbug::DeathSound( const CTakeDamageInfo &info )
{
EmitSound("ASW_MortarBug.Death");
}
// make the mortarbug look at his enemy
bool CASW_Mortarbug::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
{
Vector vecFacePosition = vec3_origin;
CBaseEntity *pFaceTarget = NULL;
bool bFaceTarget = false;
if ( GetEnemy() && GetNavigator()->GetMovementActivity() == ACT_RUN )
{
Vector vecEnemyLKP = GetEnemyLKP();
// Only start facing when we're close enough
if ( ( UTIL_DistApprox( vecEnemyLKP, GetAbsOrigin() ) < 1500 ) )
{
vecFacePosition = vecEnemyLKP;
pFaceTarget = GetEnemy();
bFaceTarget = true;
}
}
// Face
if ( bFaceTarget && asw_mortarbug_face_target.GetBool() )
{
AddFacingTarget( pFaceTarget, vecFacePosition, 1.0, 0.2 );
}
return BaseClass::OverrideMoveFacing( move, flInterval );
}
void CASW_Mortarbug::HandleAnimEvent( animevent_t *pEvent )
{
int nEvent = pEvent->Event();
if ( nEvent == AE_MORTARBUG_LAUNCH )
{
// The point in our spit animation where we should actually spawn the projectile
AttackSound();
SpawnProjectile();
m_flNextAttack = gpGlobals->curtime + 2.0f;
return;
}
else if ( nEvent == AE_MORTARBUG_CHARGE )
{
// TODO: Get ivan to make a pre-attack sound and play it here?
return;
}
BaseClass::HandleAnimEvent( pEvent );
}
// harvester can attack without LOS so long as they're near enough
bool CASW_Mortarbug::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions)
{
if (targetPos.DistTo(ownerPos) < ASW_MORTARBUG_MAX_ATTACK_DISTANCE)
return true;
return false;
}
bool CASW_Mortarbug::FCanCheckAttacks()
{
if ( GetNavType() == NAV_CLIMB || GetNavType() == NAV_JUMP )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: For innate melee attack
// Input :
// Output :
//-----------------------------------------------------------------------------
float CASW_Mortarbug::InnateRange1MinRange( void )
{
return 0;
}
float CASW_Mortarbug::InnateRange1MaxRange( void )
{
return ASW_MORTARBUG_MAX_ATTACK_DISTANCE;
}
// make sure the harvester backs away when he's near us (he should sit back and lay critters)
int CASW_Mortarbug::RangeAttack1Conditions( float flDot, float flDist )
{
if (GetEnemy() == NULL)
{
return( COND_NONE );
}
if ( gpGlobals->curtime < m_flNextAttack )
{
return( COND_NONE );
}
float flTooClose = InnateRange1MinRange();
if ( flDist > InnateRange1MaxRange() )
{
return( COND_TOO_FAR_TO_ATTACK );
}
else if ( flDist < flTooClose )
{
return( COND_TOO_CLOSE_TO_ATTACK );
}
else if ( flDot < 0.65 )
{
return( COND_NOT_FACING_ATTACK );
}
return( COND_CAN_RANGE_ATTACK1 );
}
int CASW_Mortarbug::SelectSchedule()
{
if ( HasCondition( COND_NEW_ENEMY ) && GetHealth() > 0 )
{
m_takedamage = DAMAGE_YES;
}
if ( HasCondition( COND_FLOATING_OFF_GROUND ) )
{
SetGravity( 1.0 );
SetGroundEntity( NULL );
return SCHED_FALL_TO_GROUND;
}
if (m_NPCState == NPC_STATE_COMBAT)
return SelectMortarbugCombatSchedule();
return BaseClass::SelectSchedule();
}
int CASW_Mortarbug::SelectMortarbugCombatSchedule()
{
int nSched = SelectFlinchSchedule_ASW();
if ( nSched != SCHED_NONE )
{
// if we flinch, push forward the next attack
float spawn_interval = 2.0f;
m_flNextAttack = gpGlobals->curtime + spawn_interval;
return nSched;
}
if ( HasCondition(COND_NEW_ENEMY) && gpGlobals->curtime - GetEnemies()->FirstTimeSeen(GetEnemy()) < 2.0 )
{
return SCHED_WAKE_ANGRY;
}
if ( HasCondition( COND_ENEMY_DEAD ) )
{
// clear the current (dead) enemy and try to find another.
SetEnemy( NULL );
if ( ChooseEnemy() )
{
ClearCondition( COND_ENEMY_DEAD );
return SelectSchedule();
}
SetState( NPC_STATE_ALERT );
return SelectSchedule();
}
if ( GetShotRegulator()->IsInRestInterval() )
{
if ( HasCondition(COND_CAN_RANGE_ATTACK1) )
return SCHED_COMBAT_FACE;
}
// we can see the enemy
if ( HasCondition(COND_CAN_RANGE_ATTACK1) )
{
if ( GetEnemy() )
{
m_vSavePosition = GetEnemy()->BodyTarget( GetAbsOrigin() );
//if ( CanFireMortar( GetMortarFireSource( &GetAbsOrigin() ), m_vSavePosition, false ) )
{
return SCHED_RANGE_ATTACK1;
}
}
}
if ( HasCondition(COND_CAN_RANGE_ATTACK2) )
return SCHED_RANGE_ATTACK2;
if ( HasCondition(COND_CAN_MELEE_ATTACK1) )
return SCHED_MELEE_ATTACK1;
if ( HasCondition(COND_CAN_MELEE_ATTACK2) )
return SCHED_MELEE_ATTACK2;
if ( HasCondition(COND_NOT_FACING_ATTACK) )
return SCHED_COMBAT_FACE;
return SCHED_ESTABLISH_LINE_OF_MORTAR_FIRE;
// if we're not attacking, then back away
//return SCHED_RUN_FROM_ENEMY;
}
int CASW_Mortarbug::TranslateSchedule( int scheduleType )
{
if ( scheduleType == SCHED_RANGE_ATTACK1 )
{
RemoveAllGestures();
return SCHED_ASW_MORTARBUG_SPIT;
}
if ( scheduleType == SCHED_COMBAT_FACE && IsUnreachable( GetEnemy() ) )
return SCHED_TAKE_COVER_FROM_ENEMY;
return BaseClass::TranslateSchedule( scheduleType );
}
CBaseEntity* CASW_Mortarbug::SpawnProjectile()
{
if ( !GetEnemy() )
{
return NULL;
}
// TODO: Replace with launch attachment point
Vector vSpitPos = GetAbsOrigin() + Vector( 0, 0, 10 );
GetAttachment( "attach_spit", vSpitPos );
Vector vTarget;
// If our enemy is looking at us and far enough away, lead him
if ( HasCondition( COND_ENEMY_FACING_ME ) && UTIL_DistApprox( GetAbsOrigin(), GetEnemy()->GetAbsOrigin() ) > (40*12) )
{
UTIL_PredictedPosition( GetEnemy(), 0.5f, &vTarget );
vTarget.z = GetEnemy()->GetAbsOrigin().z;
}
else
{
// Otherwise he can't see us and he won't be able to dodge
vTarget = GetEnemy()->BodyTarget( vSpitPos, true );
}
vTarget[2] += random->RandomFloat( 0.0f, 32.0f );
// Try and spit at our target
Vector vecToss;
if ( GetSpitVector( vSpitPos, vTarget, &vecToss ) == false )
{
// Now try where they were
if ( GetSpitVector( vSpitPos, m_vSavePosition, &vecToss ) == false )
{
// Failing that, just shoot with the old velocity we calculated initially!
vecToss = m_vecSaveSpitVelocity;
}
}
// Find what our vertical theta is to estimate the time we'll impact the ground
Vector vecToTarget = ( vTarget - vSpitPos );
VectorNormalize( vecToTarget );
float flVelocity = VectorNormalize( vecToss );
float flCosTheta = DotProduct( vecToTarget, vecToss );
float flTime = (vSpitPos-vTarget).Length2D() / ( flVelocity * flCosTheta );
// Emit a sound where this is going to hit so that targets get a chance to act correctly
CSoundEnt::InsertSound( SOUND_DANGER, vTarget, (15*12), flTime, this );
// Don't fire again until this volley would have hit the ground (with some lag behind it)
SetNextAttack( gpGlobals->curtime + flTime + random->RandomFloat( 0.5f, 2.0f ) );
CASW_Mortarbug_Shell *pShell = NULL;
for ( int i = 0; i < 3; i++ )
{
pShell = CASW_Mortarbug_Shell::CreateShell( vSpitPos, vecToss, this );
pShell->m_bDoScreenShake = ( i == 1 );
pShell->SetAbsVelocity( vecToss * ( flVelocity + 40.0f * (i-1) ) );
//pShell->SetAbsVelocity( ( vecToss + RandomVector( -0.035f, 0.035f ) ) * flVelocity );
}
// only do effects if we havent done them in the last second
if ( gpGlobals->curtime > m_fLastFireTime + 1.0f )
{
DispatchParticleEffect( "mortar_launch", PATTACH_POINT_FOLLOW, this, "attach_spit" );
EmitSound( "ASW_MortarBug.Spit" ); // TODO: Replace with launching sound
}
m_fLastFireTime = gpGlobals->curtime;
return pShell;
}
void CASW_Mortarbug::StartTouch( CBaseEntity *pOther )
{
BaseClass::StartTouch( pOther );
CASW_Marine *pMarine = CASW_Marine::AsMarine( pOther );
if (pMarine)
{
// don't hurt him if he was hurt recently
if (m_fLastTouchHurtTime + 0.6f > gpGlobals->curtime)
{
return;
}
// hurt the marine
Vector vecForceDir = (pMarine->GetAbsOrigin() - GetAbsOrigin());
CTakeDamageInfo info( this, this, asw_mortarbug_touch_damage.GetInt(), DMG_SLASH );
CalculateMeleeDamageForce( &info, vecForceDir, pMarine->GetAbsOrigin() );
pMarine->TakeDamage( info );
m_fLastTouchHurtTime = gpGlobals->curtime;
}
}
bool CASW_Mortarbug::ShouldGib( const CTakeDamageInfo &info )
{
return false;
}
int CASW_Mortarbug::SelectDeadSchedule()
{
// Adrian - Alread dead (by animation event maybe?)
// Is it safe to set it to SCHED_NONE?
if ( m_lifeState == LIFE_DEAD )
return SCHED_NONE;
CleanupOnDeath();
return SCHED_DIE;
}
int CASW_Mortarbug::SelectFlinchSchedule_ASW()
{
// only flinch in easy mode
if (ASWGameRules() && ASWGameRules()->GetSkillLevel() != 1)
return SCHED_NONE;
if ( !HasCondition(COND_HEAVY_DAMAGE) && !HasCondition(COND_LIGHT_DAMAGE) )
return SCHED_NONE;
if ( IsCurSchedule( SCHED_BIG_FLINCH ) )
return SCHED_NONE;
// only flinch if shot during a spit
if (! (GetTask() && (GetTask()->iTask == TASK_MORTARBUG_SPIT)) )
return SCHED_NONE;
// Any damage. Break out of my current schedule and flinch.
Activity iFlinchActivity = GetFlinchActivity( true, false );
if ( HaveSequenceForActivity( iFlinchActivity ) )
return SCHED_BIG_FLINCH;
return SCHED_NONE;
}
void CASW_Mortarbug::BuildScheduleTestBits()
{
BaseClass::BuildScheduleTestBits();
if ( IsCurSchedule( SCHED_RUN_FROM_ENEMY ) )
{
SetCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
}
}
void CASW_Mortarbug::StartTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_MORTARBUG_SPIT:
{
ResetIdealActivity((Activity) ACT_MORTARBUG_SPIT);
break;
}
case TASK_GET_PATH_TO_MORTAR_ENEMY:
{
if ( !GetEnemy() )
{
TaskFail(FAIL_NO_ENEMY);
return;
}
float flMaxRange = 2000;
float flMinRange = 100;
Vector vecEnemy = GetEnemy()->BodyTarget( GetAbsOrigin() );
int iNode = FindMortarNode( vecEnemy, flMinRange, flMaxRange, 1.0f );
if ( iNode != NO_NODE )
{
// move to the spot with line of sight
m_vInterruptSavePosition = g_pBigAINet->GetNode(iNode)->GetPosition(GetHullType());
}
else
{
TaskFail( FAIL_NO_SHOOT );
}
break;
}
default:
BaseClass::StartTask( pTask );
break;
}
}
void CASW_Mortarbug::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_MORTARBUG_SPIT:
{
if (IsActivityFinished())
{
TaskComplete();
}
break;
}
case TASK_GET_PATH_TO_MORTAR_ENEMY:
{
if ( GetEnemy() == NULL )
{
TaskFail(FAIL_NO_ENEMY);
return;
}
if ( GetTaskInterrupt() > 0 )
{
ClearTaskInterrupt();
Vector vecEnemy = GetEnemy()->GetAbsOrigin();
AI_NavGoal_t goal( m_vInterruptSavePosition, ACT_RUN, AIN_HULL_TOLERANCE );
GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET );
GetNavigator()->SetArrivalDirection( vecEnemy - goal.dest );
}
else
TaskInterrupt();
break;
}
default:
{
BaseClass::RunTask(pTask);
break;
}
}
}
// only shock damage counts as heavy (and thus causes a flinch even during normal running)
bool CASW_Mortarbug::IsHeavyDamage( const CTakeDamageInfo &info )
{
// shock damage never causes flinching
if (( info.GetDamageType() & DMG_SHOCK ) != 0 )
return false;
// explosions always cause a flinch
if (( info.GetDamageType() & DMG_BLAST ) != 0 )
return true;
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>(info.GetAttacker());
if (pMarine && pMarine->GetActiveASWWeapon())
{
return pMarine->GetActiveASWWeapon()->ShouldAlienFlinch(this, info);
}
return false;
}
void CASW_Mortarbug::Event_Killed( const CTakeDamageInfo &info )
{
BaseClass::Event_Killed(info);
m_fGibTime = gpGlobals->curtime + random->RandomFloat(20.0f, 30.0f);
}
int CASW_Mortarbug::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if ( info.GetInflictor() && info.GetInflictor()->Classify() == CLASS_ASW_MORTAR_SHELL )
return 0;
CTakeDamageInfo newInfo(info);
float damage = info.GetDamage();
// reduce damage from shotguns and mining laser
if (info.GetDamageType() & DMG_ENERGYBEAM)
{
damage *= 0.4f;
}
if (info.GetDamageType() & DMG_BUCKSHOT)
{
// hack to reduce vindicator damage (not reducing normal shotty as much as it's not too strong)
if (info.GetAttacker() && info.GetAttacker()->Classify() == CLASS_ASW_MARINE)
{
CASW_Marine *pMarine = dynamic_cast<CASW_Marine*>(info.GetAttacker());
if (pMarine)
{
CASW_Weapon_Assault_Shotgun *pVindicator = dynamic_cast<CASW_Weapon_Assault_Shotgun*>(pMarine->GetActiveASWWeapon());
if (pVindicator)
damage *= 0.45f;
else
damage *= 0.6f;
}
}
}
newInfo.SetDamage(damage);
return BaseClass::OnTakeDamage_Alive(newInfo);
}
void CASW_Mortarbug::NPCThink()
{
BaseClass::NPCThink();
if (m_fGibTime != 0 && gpGlobals->curtime > m_fGibTime)
{
CEffectData data;
data.m_vOrigin = WorldSpaceCenter();
data.m_vNormal = Vector(0,0,1);
data.m_flScale = RemapVal( m_iHealth, 0, -500, 1, 3 );
data.m_flScale = clamp( data.m_flScale, 1, 3 );
data.m_nColor = 1;
data.m_fFlags = IsOnFire() ? ASW_GIBFLAG_ON_FIRE : 0;
DispatchEffect( "HarvesterGib", data );
UTIL_Remove( this );
SetThink( NULL );
}
}
bool CASW_Mortarbug::ShouldPlayIdleSound( void )
{
return false; // asw temp
//Only do idles in the right states
if ( ( m_NPCState != NPC_STATE_IDLE && m_NPCState != NPC_STATE_ALERT ) )
return false;
//Gagged monsters don't talk
if ( m_spawnflags & SF_NPC_GAG )
return false;
//Don't cut off another sound or play again too soon
if ( m_flIdleDelay > gpGlobals->curtime )
return false;
//Randomize it a bit
if ( random->RandomInt( 0, 20 ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether the enemy has been seen within the time period supplied
// Input : flTime - Timespan we consider
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CASW_Mortarbug::SeenEnemyWithinTime( float flTime )
{
float flLastSeenTime = GetEnemies()->LastTimeSeen( GetEnemy() );
return ( flLastSeenTime != 0.0f && ( gpGlobals->curtime - flLastSeenTime ) < flTime );
}
//-----------------------------------------------------------------------------
// Purpose: Test whether this mortarbug can hit the target
//-----------------------------------------------------------------------------
bool CASW_Mortarbug::InnateWeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions )
{
if ( GetNextAttack() > gpGlobals->curtime )
return false;
// If we can see the enemy, or we've seen them in the last few seconds just try to lob in there
if ( SeenEnemyWithinTime( 3.0f ) )
{
Vector vSpitPos = GetAbsOrigin() + Vector(0, 0, 10); // TODO: replace with attachment point to fire from
return GetSpitVector( vSpitPos, targetPos, &m_vecSaveSpitVelocity );
}
return BaseClass::InnateWeaponLOSCondition( ownerPos, targetPos, bSetConditions );
}
//
// FIXME: Create this in a better fashion!
//
Vector VecCheckThrowTolerance( CBaseEntity *pEdict, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flTolerance )
{
flSpeed = MAX( 1.0f, flSpeed );
float flGravity = sv_gravity.GetFloat() * asw_mortarbug_shell_gravity.GetFloat();
Vector vecGrenadeVel = (vecSpot2 - vecSpot1);
// throw at a constant time
float time = vecGrenadeVel.Length( ) / flSpeed;
vecGrenadeVel = vecGrenadeVel * (1.0 / time);
// adjust upward toss to compensate for gravity loss
vecGrenadeVel.z += flGravity * time * 0.5;
Vector vecApex = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
vecApex.z += 0.5 * flGravity * (time * 0.5) * (time * 0.5);
trace_t tr;
UTIL_TraceLine( vecSpot1, vecApex, MASK_SOLID, pEdict, COLLISION_GROUP_NONE, &tr );
if (tr.fraction != 1.0)
{
// fail!
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Line( vecSpot1, vecApex, 255, 0, 0, true, 5.0 );
}
return vec3_origin;
}
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Line( vecSpot1, vecApex, 0, 255, 0, true, 5.0 );
}
UTIL_TraceLine( vecApex, vecSpot2, MASK_SOLID_BRUSHONLY, pEdict, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
bool bFail = true;
// Didn't make it all the way there, but check if we're within our tolerance range
if ( flTolerance > 0.0f )
{
float flNearness = ( tr.endpos - vecSpot2 ).LengthSqr();
if ( flNearness < Square( flTolerance ) )
{
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Sphere( tr.endpos, vec3_angle, flTolerance, 0, 255, 0, 0, true, 5.0 );
}
bFail = false;
}
}
if ( bFail )
{
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Line( vecApex, vecSpot2, 255, 0, 0, true, 5.0 );
NDebugOverlay::Sphere( tr.endpos, vec3_angle, flTolerance, 255, 0, 0, 0, true, 5.0 );
}
return vec3_origin;
}
}
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Line( vecApex, vecSpot2, 0, 255, 0, true, 5.0 );
}
return vecGrenadeVel;
}
//-----------------------------------------------------------------------------
// Purpose: Get a toss direction that will properly lob spit to hit a target
// Input : &vecStartPos - Where the spit will start from
// &vecTarget - Where the spit is meant to land
// *vecOut - The resulting vector to lob the spit
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CASW_Mortarbug::GetSpitVector( const Vector &vecStartPos, const Vector &vecTarget, Vector *vecOut )
{
// Try the most direct route
Vector vecToss = VecCheckThrowTolerance( this, vecStartPos, vecTarget, asw_mortarbug_spitspeed.GetFloat(), (10.0f*12.0f) );
// If this failed then try a little faster (flattens the arc)
if ( vecToss == vec3_origin )
{
vecToss = VecCheckThrowTolerance( this, vecStartPos, vecTarget, asw_mortarbug_spitspeed.GetFloat() * 1.5f, (10.0f*12.0f) );
if ( vecToss == vec3_origin )
return false;
}
// Save out the result
if ( vecOut )
{
*vecOut = vecToss;
}
return true;
}
bool CASW_Mortarbug::CanFireMortar( const Vector &vecSrc, const Vector &vecDest, bool bDrawArc )
{
float flGravity = asw_mortarbug_shell_gravity.GetFloat();
Vector vecVelocity = UTIL_LaunchVector( vecSrc, vecDest, flGravity ) * 28.0f;
Vector vecResult = UTIL_Check_Throw( vecSrc, vecVelocity, flGravity,
-Vector( 12,12,12 ), Vector( 12,12,12 ), MASK_NPCSOLID, COLLISION_GROUP_PROJECTILE, this, bDrawArc );
float flDist = vecResult.DistTo( vecDest );
return ( flDist < 50.0f );
}
Vector CASW_Mortarbug::GetMortarFireSource( const Vector *vecStandingPos )
{
Vector vecOrigin = GetAbsOrigin();
Vector vSpitPos = GetAbsOrigin() + Vector( 0, 0, 10 );
GetAttachment( "attach_spit", vSpitPos );
return *vecStandingPos + vSpitPos - vecOrigin;
}
int CASW_Mortarbug::FindMortarNode( const Vector &vThreatPos, float flMinThreatDist, float flMaxThreatDist, float flBlockTime )
{
if ( !CAI_NetworkManager::NetworksLoaded() )
return NO_NODE;
AI_PROFILE_SCOPE( CASW_Mortarbug::FindMortarNode );
Remember( bits_MEMORY_TASK_EXPENSIVE );
int iMyNode = GetPathfinder()->NearestNodeToNPC();
if ( iMyNode == NO_NODE )
{
Vector pos = GetAbsOrigin();
DevWarning( 2, "FindMortarNode() - %s has no nearest node! (Check near %f %f %f)\n", GetClassname(), pos.x, pos.y, pos.z);
return NO_NODE;
}
// ------------------------------------------------------------------------------------
// We're going to search for a shoot node by expanding to our current node's neighbors
// and then their neighbors, until a shooting position is found, or all nodes are beyond MaxDist
// ------------------------------------------------------------------------------------
AI_NearNode_t *pBuffer = (AI_NearNode_t *)stackalloc( sizeof(AI_NearNode_t) * g_pBigAINet->NumNodes() );
CNodeList list( pBuffer, g_pBigAINet->NumNodes() );
CVarBitVec wasVisited(g_pBigAINet->NumNodes()); // Nodes visited
// mark start as visited
wasVisited.Set( iMyNode );
list.Insert( AI_NearNode_t(iMyNode, 0) );
static int nSearchRandomizer = 0; // tries to ensure the links are searched in a different order each time;
while ( list.Count() )
{
int nodeIndex = list.ElementAtHead().nodeIndex;
// remove this item from the list
list.RemoveAtHead();
const Vector &nodeOrigin = g_pBigAINet->GetNode(nodeIndex)->GetPosition(GetHullType());
// HACKHACK: Can't we rework this loop and get rid of this?
// skip the starting node, or we probably wouldn't have called this function.
if ( nodeIndex != iMyNode )
{
bool skip = false;
// Don't accept climb nodes, and assume my nearest node isn't valid because
// we decided to make this check in the first place. Keep moving
if ( !skip && !g_pBigAINet->GetNode(nodeIndex)->IsLocked() &&
g_pBigAINet->GetNode(nodeIndex)->GetType() != NODE_CLIMB )
{
// Now check its distance and only accept if in range
float flThreatDist = ( nodeOrigin - vThreatPos ).Length();
if ( flThreatDist < flMaxThreatDist &&
flThreatDist > flMinThreatDist )
{
//CAI_Node *pNode = g_pBigAINet->GetNode(nodeIndex);
if ( CanFireMortar( GetMortarFireSource( &nodeOrigin ), vThreatPos, asw_debug_mortarbug.GetInt() == 2 ) )
{
// Note when this node was used, so we don't try
// to use it again right away.
g_pBigAINet->GetNode(nodeIndex)->Lock( flBlockTime );
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:los", nodeIndex), false, 1 );
// draw the arc
CanFireMortar( GetMortarFireSource( &nodeOrigin ), vThreatPos, true );
}
// The next NPC who searches should use a slight different pattern
nSearchRandomizer = nodeIndex;
return nodeIndex;
}
else
{
if ( asw_debug_mortarbug.GetBool() )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:!throw", nodeIndex), false, 1 );
}
}
}
else
{
if ( asw_debug_mortarbug.GetBool() )
{
CFmtStr msg( "%d:%s", nodeIndex, ( flThreatDist < flMaxThreatDist ) ? "too close" : "too far" );
NDebugOverlay::Text( nodeOrigin, msg, false, 1 );
}
}
}
}
// Go through each link and add connected nodes to the list
for (int link=0; link < g_pBigAINet->GetNode(nodeIndex)->NumLinks();link++)
{
int index = (link + nSearchRandomizer) % g_pBigAINet->GetNode(nodeIndex)->NumLinks();
CAI_Link *nodeLink = g_pBigAINet->GetNode(nodeIndex)->GetLinkByIndex(index);
if ( !GetPathfinder()->IsLinkUsable( nodeLink, iMyNode ) )
continue;
int newID = nodeLink->DestNodeID(nodeIndex);
// If not already visited, add to the list
if (!wasVisited.IsBitSet(newID))
{
float dist = (GetLocalOrigin() - g_pBigAINet->GetNode(newID)->GetPosition(GetHullType())).LengthSqr();
list.Insert( AI_NearNode_t(newID, dist) );
wasVisited.Set( newID );
}
}
}
// We failed. No range attack node node was found
return NO_NODE;
}
AI_BEGIN_CUSTOM_NPC( asw_mortarbug, CASW_Mortarbug )
// Tasks
DECLARE_TASK( TASK_MORTARBUG_SPIT )
DECLARE_TASK( TASK_GET_PATH_TO_MORTAR_ENEMY )
// Activities
DECLARE_ACTIVITY( ACT_MORTARBUG_SPIT )
// Events
DECLARE_ANIMEVENT( AE_MORTARBUG_CHARGE )
DECLARE_ANIMEVENT( AE_MORTARBUG_LAUNCH )
DEFINE_SCHEDULE
(
SCHED_ASW_MORTARBUG_SPIT,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MORTARBUG_SPIT 0"
""
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_ESTABLISH_LINE_OF_MORTAR_FIRE,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ESTABLISH_LINE_OF_FIRE"
" TASK_GET_PATH_TO_MORTAR_ENEMY 0"
" TASK_SPEAK_SENTENCE 1"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_COMBAT_FACE"
""
" Interrupts "
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LOST_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_MELEE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
" COND_CAN_MELEE_ATTACK2"
" COND_HEAR_DANGER"
)
AI_END_CUSTOM_NPC()
Reference in New Issue View Git Blame Copy Permalink