BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/server/hl1/hl1_npc_aflock.cpp

859 lines
22 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Bullseyes act as targets for other NPC's to attack and to trigger
// events
//
// $Workfile: $
// $Date: $
//
//-----------------------------------------------------------------------------
// $Log: $
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "ai_default.h"
#include "ai_task.h"
#include "ai_schedule.h"
#include "ai_node.h"
#include "ai_hull.h"
#include "ai_hint.h"
#include "ai_route.h"
#include "soundent.h"
#include "game.h"
#include "npcevent.h"
#include "entitylist.h"
#include "activitylist.h"
#include "animation.h"
#include "basecombatweapon.h"
#include "IEffects.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "ammodef.h"
#include "hl1_ai_basenpc.h"
#define AFLOCK_MAX_RECRUIT_RADIUS 1024
#define AFLOCK_FLY_SPEED 125
#define AFLOCK_TURN_RATE 75
#define AFLOCK_ACCELERATE 10
#define AFLOCK_CHECK_DIST 192
#define AFLOCK_TOO_CLOSE 100
#define AFLOCK_TOO_FAR 256
//=========================================================
//=========================================================
class CNPC_FlockingFlyerFlock : public CHL1BaseNPC
{
DECLARE_CLASS( CNPC_FlockingFlyerFlock, CHL1BaseNPC );
public:
void Spawn( void );
void Precache( void );
bool KeyValue( const char *szKeyName, const char *szValue );
void SpawnFlock( void );
// Sounds are shared by the flock
static void PrecacheFlockSounds( void );
DECLARE_DATADESC();
int m_cFlockSize;
float m_flFlockRadius;
};
BEGIN_DATADESC( CNPC_FlockingFlyerFlock )
DEFINE_FIELD( m_cFlockSize, FIELD_INTEGER ),
DEFINE_FIELD( m_flFlockRadius, FIELD_FLOAT ),
END_DATADESC()
class CNPC_FlockingFlyer : public CHL1BaseNPC
{
DECLARE_CLASS( CNPC_FlockingFlyer, CHL1BaseNPC );
public:
void Spawn( void );
void Precache( void );
void SpawnCommonCode( void );
void IdleThink( void );
void BoidAdvanceFrame( void );
void Start( void );
bool FPathBlocked( void );
void FlockLeaderThink( void );
void SpreadFlock( void );
void SpreadFlock2( void );
void MakeSound( void );
void FlockFollowerThink( void );
void Event_Killed( const CTakeDamageInfo &info );
void FallHack( void );
//void Poop ( void ); Adrian - wtf?!
int IsLeader( void ) { return m_pSquadLeader == this; }
int InSquad( void ) { return m_pSquadLeader != NULL; }
int SquadCount( void );
void SquadRemove( CNPC_FlockingFlyer *pRemove );
void SquadUnlink( void );
void SquadAdd( CNPC_FlockingFlyer *pAdd );
void SquadDisband( void );
CNPC_FlockingFlyer *m_pSquadLeader;
CNPC_FlockingFlyer *m_pSquadNext;
bool m_fTurning;// is this boid turning?
bool m_fCourseAdjust;// followers set this flag TRUE to override flocking while they avoid something
bool m_fPathBlocked;// TRUE if there is an obstacle ahead
Vector m_vecReferencePoint;// last place we saw leader
Vector m_vecAdjustedVelocity;// adjusted velocity (used when fCourseAdjust is TRUE)
float m_flGoalSpeed;
float m_flLastBlockedTime;
float m_flFakeBlockedTime;
float m_flAlertTime;
float m_flFlockNextSoundTime;
float m_flTempVar;
DECLARE_DATADESC();
};
BEGIN_DATADESC( CNPC_FlockingFlyer )
DEFINE_FIELD( m_pSquadLeader, FIELD_CLASSPTR ),
DEFINE_FIELD( m_pSquadNext, FIELD_CLASSPTR ),
DEFINE_FIELD( m_fTurning, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fCourseAdjust, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fPathBlocked, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecReferencePoint, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_vecAdjustedVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_flGoalSpeed, FIELD_FLOAT ),
DEFINE_FIELD( m_flLastBlockedTime, FIELD_TIME ),
DEFINE_FIELD( m_flFakeBlockedTime, FIELD_TIME ),
DEFINE_FIELD( m_flAlertTime, FIELD_TIME ),
DEFINE_THINKFUNC( IdleThink ),
DEFINE_THINKFUNC( Start ),
DEFINE_THINKFUNC( FlockLeaderThink ),
DEFINE_THINKFUNC( FlockFollowerThink ),
DEFINE_THINKFUNC( FallHack ),
DEFINE_FIELD( m_flFlockNextSoundTime, FIELD_TIME ),
DEFINE_FIELD( m_flTempVar, FIELD_FLOAT ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( monster_flyer, CNPC_FlockingFlyer );
LINK_ENTITY_TO_CLASS( monster_flyer_flock, CNPC_FlockingFlyerFlock );
bool CNPC_FlockingFlyerFlock::KeyValue( const char *szKeyName, const char *szValue )
{
if ( FStrEq( szKeyName, "iFlockSize" ) )
{
m_cFlockSize = atoi( szValue );
return true;
}
else if ( FStrEq( szKeyName, "flFlockRadius" ) )
{
m_flFlockRadius = atof( szValue );
return true;
}
else
BaseClass::KeyValue( szKeyName, szValue );
return false;
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyerFlock::Spawn( void )
{
Precache( );
SetRenderColor( 255, 255, 255, 255 );
SpawnFlock();
SetThink( &CBaseEntity::SUB_Remove );
SetNextThink( gpGlobals->curtime + 0.1f );
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyerFlock::Precache( void )
{
//PRECACHE_MODEL("models/aflock.mdl");
PrecacheModel("models/boid.mdl");
PrecacheFlockSounds();
}
void CNPC_FlockingFlyerFlock::SpawnFlock( void )
{
float R = m_flFlockRadius;
int iCount;
Vector vecSpot;
CNPC_FlockingFlyer *pBoid, *pLeader;
pLeader = pBoid = NULL;
for ( iCount = 0 ; iCount < m_cFlockSize ; iCount++ )
{
pBoid = CREATE_ENTITY( CNPC_FlockingFlyer, "monster_flyer" );
if ( !pLeader )
{
// make this guy the leader.
pLeader = pBoid;
pLeader->m_pSquadLeader = pLeader;
pLeader->m_pSquadNext = NULL;
}
vecSpot.x = random->RandomFloat( -R, R );
vecSpot.y = random->RandomFloat( -R, R );
vecSpot.z = random->RandomFloat( 0, 16 );
vecSpot = GetAbsOrigin() + vecSpot;
UTIL_SetOrigin( pBoid, vecSpot);
pBoid->SetMoveType( MOVETYPE_FLY );
pBoid->SpawnCommonCode();
pBoid->SetGroundEntity( NULL );
pBoid->SetAbsVelocity( Vector ( 0, 0, 0 ) );
pBoid->SetAbsAngles( GetAbsAngles() );
pBoid->SetCycle( 0 );
pBoid->SetThink( &CNPC_FlockingFlyer::IdleThink );
pBoid->SetNextThink( gpGlobals->curtime + 0.2 );
if ( pBoid != pLeader )
{
pLeader->SquadAdd( pBoid );
}
}
}
void CNPC_FlockingFlyerFlock::PrecacheFlockSounds( void )
{
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::Spawn( )
{
Precache( );
SpawnCommonCode();
SetCycle( 0 );
SetNextThink( gpGlobals->curtime + 0.1f );
SetThink( &CNPC_FlockingFlyer::IdleThink );
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::SpawnCommonCode( )
{
m_lifeState = LIFE_ALIVE;
SetClassname( "monster_flyer" );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_FLY );
m_takedamage = DAMAGE_NO;
m_iHealth = 1;
m_fPathBlocked = FALSE;// obstacles will be detected
m_flFieldOfView = 0.2;
m_flTempVar = 0;
//SET_MODEL(ENT(pev), "models/aflock.mdl");
SetModel( "models/boid.mdl" );
// UTIL_SetSize(this, Vector(0,0,0), Vector(0,0,0));
UTIL_SetSize(this, Vector(-5,-5,0), Vector(5,5,2));
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::Precache( )
{
//PRECACHE_MODEL("models/aflock.mdl");
PrecacheModel("models/boid.mdl");
CNPC_FlockingFlyerFlock::PrecacheFlockSounds();
PrecacheScriptSound( "FlockingFlyer.Alert" );
PrecacheScriptSound( "FlockingFlyer.Idle" );
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::IdleThink( void )
{
SetNextThink( gpGlobals->curtime + 0.2 );
// see if there's a client in the same pvs as the monster
if ( !FNullEnt( UTIL_FindClientInPVS( edict() ) ) )
{
SetThink( &CNPC_FlockingFlyer::Start );
SetNextThink( gpGlobals->curtime + 0.1f );
}
}
//=========================================================
//
// SquadUnlink(), Unlink the squad pointers.
//
//=========================================================
void CNPC_FlockingFlyer::SquadUnlink( void )
{
m_pSquadLeader = NULL;
m_pSquadNext = NULL;
}
//=========================================================
//
// SquadAdd(), add pAdd to my squad
//
//=========================================================
void CNPC_FlockingFlyer::SquadAdd( CNPC_FlockingFlyer *pAdd )
{
ASSERT( pAdd!=NULL );
ASSERT( !pAdd->InSquad() );
ASSERT( this->IsLeader() );
pAdd->m_pSquadNext = m_pSquadNext;
m_pSquadNext = pAdd;
pAdd->m_pSquadLeader = this;
}
//=========================================================
//
// SquadRemove(), remove pRemove from my squad.
// If I am pRemove, promote m_pSquadNext to leader
//
//=========================================================
void CNPC_FlockingFlyer::SquadRemove( CNPC_FlockingFlyer *pRemove )
{
ASSERT( pRemove!=NULL );
ASSERT( this->IsLeader() );
ASSERT( pRemove->m_pSquadLeader == this );
if ( SquadCount() > 2 )
{
// Removing the leader, promote m_pSquadNext to leader
if ( pRemove == this )
{
CNPC_FlockingFlyer *pLeader = m_pSquadNext;
// copy the enemy LKP to the new leader
// if ( GetEnemy() )
// pLeader->m_vecEnemyLKP = m_vecEnemyLKP;
if ( pLeader )
{
CNPC_FlockingFlyer *pList = pLeader;
while ( pList )
{
pList->m_pSquadLeader = pLeader;
pList = pList->m_pSquadNext;
}
}
SquadUnlink();
}
else // removing a node
{
CNPC_FlockingFlyer *pList = this;
// Find the node before pRemove
while ( pList->m_pSquadNext != pRemove )
{
// assert to test valid list construction
ASSERT( pList->m_pSquadNext != NULL );
pList = pList->m_pSquadNext;
}
// List validity
ASSERT( pList->m_pSquadNext == pRemove );
// Relink without pRemove
pList->m_pSquadNext = pRemove->m_pSquadNext;
// Unlink pRemove
pRemove->SquadUnlink();
}
}
else
SquadDisband();
}
//=========================================================
//
// SquadCount(), return the number of members of this squad
// callable from leaders & followers
//
//=========================================================
int CNPC_FlockingFlyer::SquadCount( void )
{
CNPC_FlockingFlyer *pList = m_pSquadLeader;
int squadCount = 0;
while ( pList )
{
squadCount++;
pList = pList->m_pSquadNext;
}
return squadCount;
}
//=========================================================
//
// SquadDisband(), Unlink all squad members
//
//=========================================================
void CNPC_FlockingFlyer::SquadDisband( void )
{
CNPC_FlockingFlyer *pList = m_pSquadLeader;
CNPC_FlockingFlyer *pNext;
while ( pList )
{
pNext = pList->m_pSquadNext;
pList->SquadUnlink();
pList = pNext;
}
}
//=========================================================
// Start - player enters the pvs, so get things going.
//=========================================================
void CNPC_FlockingFlyer::Start( void )
{
SetNextThink( gpGlobals->curtime + 0.1f );
if ( IsLeader() )
{
SetThink( &CNPC_FlockingFlyer::FlockLeaderThink );
}
else
{
SetThink( &CNPC_FlockingFlyer::FlockFollowerThink );
}
SetActivity ( ACT_FLY );
ResetSequenceInfo( );
BoidAdvanceFrame( );
m_flSpeed = AFLOCK_FLY_SPEED;// no delay!
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::BoidAdvanceFrame ( void )
{
float flapspeed = ( m_flSpeed - m_flTempVar ) / AFLOCK_ACCELERATE;
m_flTempVar = m_flTempVar * .8 + m_flSpeed * .2;
if (flapspeed < 0) flapspeed = -flapspeed;
if (flapspeed < 0.25) flapspeed = 0.25;
if (flapspeed > 1.9) flapspeed = 1.9;
m_flPlaybackRate = flapspeed;
QAngle angVel = GetLocalAngularVelocity();
// lean
angVel.x = - GetAbsAngles().x + flapspeed * 5;
// bank
angVel.z = - GetAbsAngles().z + angVel.y;
SetLocalAngularVelocity( angVel );
// pev->framerate = flapspeed;
StudioFrameAdvance();
}
//=========================================================
// Leader boids use this think every tenth
//=========================================================
void CNPC_FlockingFlyer::FlockLeaderThink( void )
{
trace_t tr;
Vector vecDist;// used for general measurements
Vector vecDir;// used for general measurements
float flLeftSide;
float flRightSide;
Vector vForward, vRight, vUp;
SetNextThink( gpGlobals->curtime + 0.1f );
AngleVectors ( GetAbsAngles(), &vForward, &vRight, &vUp );
// is the way ahead clear?
if ( !FPathBlocked () )
{
// if the boid is turning, stop the trend.
if ( m_fTurning )
{
m_fTurning = FALSE;
QAngle angVel = GetLocalAngularVelocity();
angVel.y = 0;
SetLocalAngularVelocity( angVel );
}
m_fPathBlocked = FALSE;
if ( m_flSpeed <= AFLOCK_FLY_SPEED )
m_flSpeed += 5;
SetAbsVelocity( vForward * m_flSpeed );
BoidAdvanceFrame( );
return;
}
// IF we get this far in the function, the leader's path is blocked!
m_fPathBlocked = TRUE;
if ( !m_fTurning)// something in the way and boid is not already turning to avoid
{
// measure clearance on left and right to pick the best dir to turn
UTIL_TraceLine(GetAbsOrigin(), GetAbsOrigin() + vRight * AFLOCK_CHECK_DIST, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
vecDist = (tr.endpos - GetAbsOrigin());
flRightSide = vecDist.Length();
UTIL_TraceLine(GetAbsOrigin(), GetAbsOrigin() - vRight * AFLOCK_CHECK_DIST, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
vecDist = (tr.endpos - GetAbsOrigin());
flLeftSide = vecDist.Length();
// turn right if more clearance on right side
if ( flRightSide > flLeftSide )
{
QAngle angVel = GetLocalAngularVelocity();
angVel.y = -AFLOCK_TURN_RATE;
SetLocalAngularVelocity( angVel );
m_fTurning = TRUE;
}
// default to left turn :)
else if ( flLeftSide > flRightSide )
{
QAngle angVel = GetLocalAngularVelocity();
angVel.y = AFLOCK_TURN_RATE;
SetLocalAngularVelocity( angVel );
m_fTurning = TRUE;
}
else
{
// equidistant. Pick randomly between left and right.
m_fTurning = TRUE;
QAngle angVel = GetLocalAngularVelocity();
if ( random->RandomInt( 0, 1 ) == 0 )
{
angVel.y = AFLOCK_TURN_RATE;
}
else
{
angVel.y = -AFLOCK_TURN_RATE;
}
SetLocalAngularVelocity( angVel );
}
}
SpreadFlock( );
SetAbsVelocity( vForward * m_flSpeed );
// check and make sure we aren't about to plow into the ground, don't let it happen
UTIL_TraceLine(GetAbsOrigin(), GetAbsOrigin() - vUp * 16, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0 && GetAbsVelocity().z < 0 )
{
Vector vecVel = GetAbsVelocity();
vecVel.z = 0;
SetAbsVelocity( vecVel );
}
// maybe it did, though.
if ( GetFlags() & FL_ONGROUND )
{
UTIL_SetOrigin( this, GetAbsOrigin() + Vector ( 0 , 0 , 1 ) );
Vector vecVel = GetAbsVelocity();
vecVel.z = 0;
SetAbsVelocity( vecVel );
}
if ( m_flFlockNextSoundTime < gpGlobals->curtime )
{
// MakeSound();
m_flFlockNextSoundTime = gpGlobals->curtime + random->RandomFloat( 1, 3 );
}
BoidAdvanceFrame( );
return;
}
//=========================================================
// FBoidPathBlocked - returns TRUE if there is an obstacle ahead
//=========================================================
bool CNPC_FlockingFlyer::FPathBlocked( void )
{
trace_t tr;
Vector vecDist;// used for general measurements
Vector vecDir;// used for general measurements
bool fBlocked;
Vector vForward, vRight, vUp;
if ( m_flFakeBlockedTime > gpGlobals->curtime )
{
m_flLastBlockedTime = gpGlobals->curtime;
return TRUE;
}
// use VELOCITY, not angles, not all boids point the direction they are flying
//vecDir = UTIL_VecToAngles( pevBoid->velocity );
AngleVectors ( GetAbsAngles(), &vForward, &vRight, &vUp );
fBlocked = FALSE;// assume the way ahead is clear
// check for obstacle ahead
UTIL_TraceLine(GetAbsOrigin(), GetAbsOrigin() + vForward * AFLOCK_CHECK_DIST, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0)
{
m_flLastBlockedTime = gpGlobals->curtime;
fBlocked = TRUE;
}
// extra wide checks
UTIL_TraceLine(GetAbsOrigin() + vRight * 12, GetAbsOrigin() + vRight * 12 + vForward * AFLOCK_CHECK_DIST, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0)
{
m_flLastBlockedTime = gpGlobals->curtime;
fBlocked = TRUE;
}
UTIL_TraceLine(GetAbsOrigin() - vRight * 12, GetAbsOrigin() - vRight * 12 + vForward * AFLOCK_CHECK_DIST, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0)
{
m_flLastBlockedTime = gpGlobals->curtime;
fBlocked = TRUE;
}
if ( !fBlocked && gpGlobals->curtime - m_flLastBlockedTime > 6 )
{
// not blocked, and it's been a few seconds since we've actually been blocked.
m_flFakeBlockedTime = gpGlobals->curtime + random->RandomInt(1, 3);
}
return fBlocked;
}
//=========================================================
// Searches for boids that are too close and pushes them away
//=========================================================
void CNPC_FlockingFlyer::SpreadFlock( )
{
Vector vecDir;
float flSpeed;// holds vector magnitude while we fiddle with the direction
CNPC_FlockingFlyer *pList = m_pSquadLeader;
while ( pList )
{
if ( pList != this && ( GetAbsOrigin() - pList->GetAbsOrigin() ).Length() <= AFLOCK_TOO_CLOSE )
{
// push the other away
vecDir = ( pList->GetAbsOrigin() - GetAbsOrigin() );
VectorNormalize( vecDir );
// store the magnitude of the other boid's velocity, and normalize it so we
// can average in a course that points away from the leader.
flSpeed = pList->GetAbsVelocity().Length();
Vector vecVel = pList->GetAbsVelocity();
VectorNormalize( vecVel );
pList->SetAbsVelocity( ( vecVel + vecDir ) * 0.5 * flSpeed );
}
pList = pList->m_pSquadNext;
}
}
//=========================================================
// Alters the caller's course if he's too close to others
//
// This function should **ONLY** be called when Caller's velocity is normalized!!
//=========================================================
void CNPC_FlockingFlyer::SpreadFlock2 ( )
{
Vector vecDir;
CNPC_FlockingFlyer *pList = m_pSquadLeader;
while ( pList )
{
if ( pList != this && ( GetAbsOrigin() - pList->GetAbsOrigin() ).Length() <= AFLOCK_TOO_CLOSE )
{
vecDir = ( GetAbsOrigin() - pList->GetAbsOrigin() );
VectorNormalize( vecDir );
SetAbsVelocity( ( GetAbsVelocity() + vecDir ) );
}
pList = pList->m_pSquadNext;
}
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::MakeSound( void )
{
if ( m_flAlertTime > gpGlobals->curtime )
{
CPASAttenuationFilter filter1( this );
// make agitated sounds
EmitSound( filter1, entindex(), "FlockingFlyer.Alert" );
return;
}
// make normal sound
CPASAttenuationFilter filter2( this );
EmitSound( filter2, entindex(), "FlockingFlyer.Idle" );
}
//=========================================================
// follower boids execute this code when flocking
//=========================================================
void CNPC_FlockingFlyer::FlockFollowerThink( void )
{
Vector vecDist;
Vector vecDir;
Vector vecDirToLeader;
float flDistToLeader;
SetNextThink( gpGlobals->curtime + 0.1f );
if ( IsLeader() || !InSquad() )
{
// the leader has been killed and this flyer suddenly finds himself the leader.
SetThink ( &CNPC_FlockingFlyer::FlockLeaderThink );
return;
}
vecDirToLeader = ( m_pSquadLeader->GetAbsOrigin() - GetAbsOrigin() );
flDistToLeader = vecDirToLeader.Length();
// match heading with leader
SetAbsAngles( m_pSquadLeader->GetAbsAngles() );
//
// We can see the leader, so try to catch up to it
//
if ( FInViewCone ( m_pSquadLeader ) )
{
// if we're too far away, speed up
if ( flDistToLeader > AFLOCK_TOO_FAR )
{
m_flGoalSpeed = m_pSquadLeader->GetAbsVelocity().Length() * 1.5;
}
// if we're too close, slow down
else if ( flDistToLeader < AFLOCK_TOO_CLOSE )
{
m_flGoalSpeed = m_pSquadLeader->GetAbsVelocity().Length() * 0.5;
}
}
else
{
// wait up! the leader isn't out in front, so we slow down to let him pass
m_flGoalSpeed = m_pSquadLeader->GetAbsVelocity().Length() * 0.5;
}
SpreadFlock2();
Vector vecVel = GetAbsVelocity();
m_flSpeed = vecVel.Length();
VectorNormalize( vecVel );
// if we are too far from leader, average a vector towards it into our current velocity
if ( flDistToLeader > AFLOCK_TOO_FAR )
{
VectorNormalize( vecDirToLeader );
vecVel = (vecVel + vecDirToLeader) * 0.5;
}
// clamp speeds and handle acceleration
if ( m_flGoalSpeed > AFLOCK_FLY_SPEED * 2 )
{
m_flGoalSpeed = AFLOCK_FLY_SPEED * 2;
}
if ( m_flSpeed < m_flGoalSpeed )
{
m_flSpeed += AFLOCK_ACCELERATE;
}
else if ( m_flSpeed > m_flGoalSpeed )
{
m_flSpeed -= AFLOCK_ACCELERATE;
}
SetAbsVelocity( vecVel * m_flSpeed );
BoidAdvanceFrame( );
}
//=========================================================
//=========================================================
void CNPC_FlockingFlyer::Event_Killed( const CTakeDamageInfo &info )
{
CNPC_FlockingFlyer *pSquad;
pSquad = (CNPC_FlockingFlyer *)m_pSquadLeader;
while ( pSquad )
{
pSquad->m_flAlertTime = gpGlobals->curtime + 15;
pSquad = (CNPC_FlockingFlyer *)pSquad->m_pSquadNext;
}
if ( m_pSquadLeader )
{
m_pSquadLeader->SquadRemove( this );
}
m_lifeState = LIFE_DEAD;
m_flPlaybackRate = 0;
IncrementInterpolationFrame();
UTIL_SetSize( this, Vector(0,0,0), Vector(0,0,0) );
SetMoveType( MOVETYPE_FLYGRAVITY );
SetThink ( &CNPC_FlockingFlyer::FallHack );
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CNPC_FlockingFlyer::FallHack( void )
{
if ( GetFlags() & FL_ONGROUND )
{
CBaseEntity *groundentity = GetContainingEntity( GetGroundEntity()->edict() );
if ( !FClassnameIs ( groundentity, "worldspawn" ) )
{
SetGroundEntity( NULL );
SetNextThink( gpGlobals->curtime + 0.1f );
}
else
{
SetAbsVelocity( Vector( 0, 0, 0 ) );
SetThink( NULL );
}
}
}
Reference in New Issue View Git Blame Copy Permalink