You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1380 lines
39 KiB
1380 lines
39 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// npc_blob - experimental, cpu-intensive monster made of lots of smaller elements
|
||
|
//
|
||
|
//=============================================================================//
|
||
|
#include "cbase.h"
|
||
|
#include "ai_default.h"
|
||
|
#include "ai_task.h"
|
||
|
#include "ai_schedule.h"
|
||
|
#include "ai_hull.h"
|
||
|
#include "soundent.h"
|
||
|
#include "game.h"
|
||
|
#include "npcevent.h"
|
||
|
#include "entitylist.h"
|
||
|
#include "activitylist.h"
|
||
|
#include "ai_basenpc.h"
|
||
|
#include "engine/IEngineSound.h"
|
||
|
#include "vstdlib/jobthread.h"
|
||
|
#include "saverestore_utlvector.h"
|
||
|
#include "eventqueue.h"
|
||
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
extern float MOVE_HEIGHT_EPSILON;
|
||
|
|
||
|
#define BLOB_MAX_AVOID_ORIGINS 3
|
||
|
|
||
|
ConVar blob_mindist( "blob_mindist", "120.0" );
|
||
|
ConVar blob_element_speed( "blob_element_speed", "187" );
|
||
|
ConVar npc_blob_idle_speed_factor( "npc_blob_idle_speed_factor", "0.5" );
|
||
|
|
||
|
ConVar blob_numelements( "blob_numelements", "20" );
|
||
|
ConVar blob_batchpercent( "blob_batchpercent", "100" );
|
||
|
|
||
|
ConVar blob_radius( "blob_radius", "160" );
|
||
|
|
||
|
//ConVar blob_min_element_speed( "blob_min_element_speed", "50" );
|
||
|
//ConVar blob_max_element_speed( "blob_max_element_speed", "250" );
|
||
|
|
||
|
ConVar npc_blob_use_threading( "npc_blob_use_threading", "1" );
|
||
|
|
||
|
ConVar npc_blob_sin_amplitude( "npc_blob_sin_amplitude", "60.0f" );
|
||
|
|
||
|
ConVar npc_blob_show_centroid( "npc_blob_show_centroid", "0" );
|
||
|
|
||
|
ConVar npc_blob_straggler_dist( "npc_blob_straggler_dist", "240" );
|
||
|
|
||
|
ConVar npc_blob_use_orientation( "npc_blob_use_orientation", "1" );
|
||
|
ConVar npc_blob_use_model( "npc_blob_use_model", "2" );
|
||
|
|
||
|
ConVar npc_blob_think_interval( "npc_blob_think_interval", "0.025" );
|
||
|
|
||
|
|
||
|
#define NPC_BLOB_MODEL "models/headcrab.mdl"
|
||
|
|
||
|
//=========================================================
|
||
|
// Blob movement rules
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
BLOB_MOVE_SWARM = 0, // Just swarm with the rest of the group
|
||
|
BLOB_MOVE_TO_TARGET_LOCATION, // Move to a designated location
|
||
|
BLOB_MOVE_TO_TARGET_ENTITY, // Chase the designated entity
|
||
|
BLOB_MOVE_DONT_MOVE, // Sit still!!!!
|
||
|
};
|
||
|
|
||
|
//=========================================================
|
||
|
//=========================================================
|
||
|
class CBlobElement : public CBaseAnimating
|
||
|
{
|
||
|
public:
|
||
|
void Precache();
|
||
|
void Spawn();
|
||
|
int DrawDebugTextOverlays(void);
|
||
|
|
||
|
void SetElementVelocity( Vector vecVelocity, bool bPlanarOnly );
|
||
|
void AddElementVelocity( Vector vecVelocityAdd, bool bPlanarOnly );
|
||
|
void ModifyVelocityForSurface( float flInterval, float flSpeed );
|
||
|
|
||
|
void SetSinePhase( float flPhase ) { m_flSinePhase = flPhase; }
|
||
|
float GetSinePhase() { return m_flSinePhase; }
|
||
|
|
||
|
float GetSineAmplitude() { return m_flSineAmplitude; }
|
||
|
float GetSineFrequency() { return m_flSineFrequency; }
|
||
|
|
||
|
void SetActiveMovementRule( int moveRule ) { m_iMovementRule = moveRule; }
|
||
|
int GetActiveMovementRule() { return m_iMovementRule; }
|
||
|
|
||
|
void MoveTowardsTargetEntity( float speed );
|
||
|
void SetTargetEntity( CBaseEntity *pEntity ) { m_hTargetEntity = pEntity; }
|
||
|
CBaseEntity *GetTargetEntity() { return m_hTargetEntity.Get(); }
|
||
|
|
||
|
void MoveTowardsTargetLocation( float speed );
|
||
|
void SetTargetLocation( const Vector &vecLocation ) { m_vecTargetLocation = vecLocation; }
|
||
|
|
||
|
void ReconfigureRandomParams();
|
||
|
void EnforceSpeedLimits( float flMinSpeed, float flMaxSpeed );
|
||
|
|
||
|
DECLARE_DATADESC();
|
||
|
|
||
|
public:
|
||
|
Vector m_vecPrevOrigin; // Only exists for debugging (isolating stuck elements)
|
||
|
int m_iStuckCount;
|
||
|
bool m_bOnWall;
|
||
|
float m_flDistFromCentroidSqr;
|
||
|
int m_iElementNumber;
|
||
|
Vector m_vecTargetLocation;
|
||
|
float m_flRandomEightyPercent;
|
||
|
|
||
|
private:
|
||
|
EHANDLE m_hTargetEntity;
|
||
|
float m_flSinePhase;
|
||
|
float m_flSineAmplitude;
|
||
|
float m_flSineFrequency;
|
||
|
int m_iMovementRule;
|
||
|
};
|
||
|
LINK_ENTITY_TO_CLASS( blob_element, CBlobElement );
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Save/Restore
|
||
|
//---------------------------------------------------------
|
||
|
BEGIN_DATADESC( CBlobElement )
|
||
|
|
||
|
DEFINE_FIELD( m_vecPrevOrigin, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( m_iStuckCount, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_bOnWall, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_flDistFromCentroidSqr, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_iElementNumber, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_vecTargetLocation, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( m_hTargetEntity, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_flSinePhase, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_flSineAmplitude, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_flSineFrequency, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_iMovementRule, FIELD_INTEGER ),
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
|
||
|
const char *pszBlobModels[] =
|
||
|
{
|
||
|
"models/gibs/agibs.mdl",
|
||
|
"models/props_junk/watermelon01.mdl",
|
||
|
"models/w_squeak.mdl",
|
||
|
"models/baby_headcrab.mdl"
|
||
|
};
|
||
|
|
||
|
const char *GetBlobModelName()
|
||
|
{
|
||
|
int index = npc_blob_use_model.GetInt();
|
||
|
|
||
|
return pszBlobModels[ index ];
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::Precache()
|
||
|
{
|
||
|
PrecacheModel( GetBlobModelName() );
|
||
|
|
||
|
m_flRandomEightyPercent = random->RandomFloat( 0.8f, 1.0f );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::Spawn()
|
||
|
{
|
||
|
Precache();
|
||
|
|
||
|
SetSolid( SOLID_NONE );
|
||
|
SetMoveType( MOVETYPE_FLY );
|
||
|
AddSolidFlags( FSOLID_NOT_STANDABLE | FSOLID_NOT_SOLID );
|
||
|
|
||
|
SetModel( GetBlobModelName() );
|
||
|
UTIL_SetSize( this, vec3_origin, vec3_origin );
|
||
|
|
||
|
QAngle angles(0,0,0);
|
||
|
angles.y = random->RandomFloat( 0, 180 );
|
||
|
SetAbsAngles( angles );
|
||
|
|
||
|
AddEffects( EF_NOSHADOW );
|
||
|
|
||
|
ReconfigureRandomParams();
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
int CBlobElement::DrawDebugTextOverlays(void)
|
||
|
{
|
||
|
int text_offset = BaseClass::DrawDebugTextOverlays();
|
||
|
if (m_debugOverlays & OVERLAY_TEXT_BIT)
|
||
|
{
|
||
|
char tempstr[512];
|
||
|
Q_snprintf(tempstr,sizeof(tempstr), "Element #:%d", m_iElementNumber );
|
||
|
EntityText(text_offset,tempstr,0);
|
||
|
text_offset++;
|
||
|
}
|
||
|
return text_offset;
|
||
|
}
|
||
|
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// This is the official way to set velocity for an element
|
||
|
// Do not call SetAbsVelocity() directly, since we also
|
||
|
// need to record the last velocity we intended to give the
|
||
|
// element, so that we can detect changes after game physics
|
||
|
// runs.
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::SetElementVelocity( Vector vecVelocity, bool bPlanarOnly )
|
||
|
{
|
||
|
SetAbsVelocity( vecVelocity );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// This is the official way to add velocity to an element.
|
||
|
// See SetElementVelocity() for explanation.
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::AddElementVelocity( Vector vecVelocityAdd, bool bPlanarOnly )
|
||
|
{
|
||
|
Vector vecSum = GetAbsVelocity() + vecVelocityAdd;
|
||
|
SetAbsVelocity( vecSum );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// This function seeks to keep the blob element moving along
|
||
|
// multiple different types of surfaces (climbing walls, etc)
|
||
|
//---------------------------------------------------------
|
||
|
#define BLOB_TRACE_HEIGHT 8.0f
|
||
|
void CBlobElement::ModifyVelocityForSurface( float flInterval, float flSpeed )
|
||
|
{
|
||
|
trace_t tr;
|
||
|
Vector vecStart = GetAbsOrigin();
|
||
|
Vector up = Vector( 0, 0, BLOB_TRACE_HEIGHT );
|
||
|
|
||
|
Vector vecWishedGoal = vecStart + (GetAbsVelocity() * flInterval);
|
||
|
|
||
|
UTIL_TraceLine( vecStart + up, vecWishedGoal + up, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
||
|
|
||
|
//NDebugOverlay::Line( tr.startpos, tr.endpos, 255, 0, 0, false, 0.1f );
|
||
|
|
||
|
m_bOnWall = false;
|
||
|
|
||
|
if( tr.fraction == 1.0f )
|
||
|
{
|
||
|
UTIL_TraceLine( vecWishedGoal + up, vecWishedGoal - (up * 2.0f), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
||
|
//NDebugOverlay::Line( tr.startpos, tr.endpos, 255, 255, 0, false, 0.1f );
|
||
|
tr.endpos.z += MOVE_HEIGHT_EPSILON;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//NDebugOverlay::Cross3D( GetAbsOrigin(), 16, 255, 255, 0, false, 0.025f );
|
||
|
|
||
|
m_bOnWall = true;
|
||
|
|
||
|
if( tr.m_pEnt != NULL && !tr.m_pEnt->IsWorld() )
|
||
|
{
|
||
|
IPhysicsObject *pPhysics = tr.m_pEnt->VPhysicsGetObject();
|
||
|
|
||
|
if( pPhysics != NULL )
|
||
|
{
|
||
|
Vector vecMassCenter;
|
||
|
Vector vecMassCenterWorld;
|
||
|
|
||
|
vecMassCenter = pPhysics->GetMassCenterLocalSpace();
|
||
|
pPhysics->LocalToWorld( &vecMassCenterWorld, vecMassCenter );
|
||
|
|
||
|
if( tr.endpos.z > vecMassCenterWorld.z )
|
||
|
{
|
||
|
pPhysics->ApplyForceOffset( (-150.0f * m_flRandomEightyPercent) * tr.plane.normal, tr.endpos );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Vector vecDir = tr.endpos - vecStart;
|
||
|
VectorNormalize( vecDir );
|
||
|
SetElementVelocity( vecDir * flSpeed, false );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Set velocity that will carry me towards a specified entity
|
||
|
// Most often used to move along with the npc_blob that
|
||
|
// is directing me.
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::MoveTowardsTargetEntity( float speed )
|
||
|
{
|
||
|
CBaseEntity *pTarget = m_hTargetEntity.Get();
|
||
|
|
||
|
if( pTarget != NULL )
|
||
|
{
|
||
|
// Try to attack my target's enemy directly if I can.
|
||
|
CBaseEntity *pTargetEnemy = pTarget->GetEnemy();
|
||
|
|
||
|
if( pTargetEnemy != NULL )
|
||
|
{
|
||
|
pTarget = pTargetEnemy;
|
||
|
}
|
||
|
|
||
|
Vector vecDir = pTarget->WorldSpaceCenter() - GetAbsOrigin();
|
||
|
vecDir.NormalizeInPlace();
|
||
|
SetElementVelocity( vecDir * speed, true );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SetElementVelocity( vec3_origin, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Set velocity that will take me towards a specified location.
|
||
|
// This is often used to send all blob elements to specific
|
||
|
// locations, causing the blob to appear as though it has
|
||
|
// formed a specific shape.
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::MoveTowardsTargetLocation( float speed )
|
||
|
{
|
||
|
Vector vecDir = m_vecTargetLocation - GetAbsOrigin();
|
||
|
float dist = VectorNormalize( vecDir );
|
||
|
|
||
|
//!!!HACKHACK - how about a real way to tell if we've reached our goal?
|
||
|
if( dist <= 8.0f )
|
||
|
{
|
||
|
SetActiveMovementRule( BLOB_MOVE_DONT_MOVE );
|
||
|
}
|
||
|
|
||
|
speed = MIN( dist, speed );
|
||
|
|
||
|
SetElementVelocity( vecDir * speed, true );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Pick new random numbers for the parameters that create
|
||
|
// variations in movement.
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::ReconfigureRandomParams()
|
||
|
{
|
||
|
m_flSinePhase = random->RandomFloat( 0.01f, 0.9f );
|
||
|
m_flSineFrequency = random->RandomFloat( 10.0f, 20.0f );
|
||
|
m_flSineAmplitude = random->RandomFloat( 0.5f, 1.5f );
|
||
|
}
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Adjust velocity if this element is moving faster than
|
||
|
// flMaxSpeed or slower than flMinSpeed
|
||
|
//---------------------------------------------------------
|
||
|
void CBlobElement::EnforceSpeedLimits( float flMinSpeed, float flMaxSpeed )
|
||
|
{
|
||
|
Vector vecVelocity = GetAbsVelocity();
|
||
|
float flSpeed = VectorNormalize( vecVelocity );
|
||
|
|
||
|
if( flSpeed > flMaxSpeed )
|
||
|
{
|
||
|
SetElementVelocity( vecVelocity * flMaxSpeed, true );
|
||
|
}
|
||
|
else if( flSpeed < flMinSpeed )
|
||
|
{
|
||
|
SetElementVelocity( vecVelocity * flMinSpeed, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//=========================================================
|
||
|
// Custom schedules
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
SCHED_MYCUSTOMSCHEDULE = LAST_SHARED_SCHEDULE,
|
||
|
};
|
||
|
|
||
|
//=========================================================
|
||
|
// Custom tasks
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
TASK_MYCUSTOMTASK = LAST_SHARED_TASK,
|
||
|
};
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
// Custom Conditions
|
||
|
//=========================================================
|
||
|
enum
|
||
|
{
|
||
|
COND_MYCUSTOMCONDITION = LAST_SHARED_CONDITION,
|
||
|
};
|
||
|
|
||
|
|
||
|
//=========================================================
|
||
|
//=========================================================
|
||
|
class CNPC_Blob : public CAI_BaseNPC
|
||
|
{
|
||
|
DECLARE_CLASS( CNPC_Blob, CAI_BaseNPC );
|
||
|
|
||
|
public:
|
||
|
CNPC_Blob();
|
||
|
void Precache( void );
|
||
|
void Spawn( void );
|
||
|
Class_T Classify( void );
|
||
|
void RunAI();
|
||
|
void GatherConditions( void );
|
||
|
int SelectSchedule( void );
|
||
|
int GetSoundInterests( void ) { return (SOUND_BUGBAIT); }
|
||
|
|
||
|
|
||
|
void ComputeCentroid();
|
||
|
|
||
|
void DoBlobBatchedAI( int iStart, int iEnd );
|
||
|
|
||
|
int ComputeBatchSize();
|
||
|
void AdvanceBatch();
|
||
|
int GetBatchStart();
|
||
|
int GetBatchEnd();
|
||
|
|
||
|
CBlobElement *CreateNewElement();
|
||
|
void InitializeElements();
|
||
|
void RecomputeIdealElementDist();
|
||
|
|
||
|
void RemoveAllElementsExcept( int iExempt );
|
||
|
|
||
|
void RemoveExcessElements( int iNumElements );
|
||
|
void AddNewElements( int iNumElements );
|
||
|
|
||
|
void FormShapeFromPath( string_t iszPathName );
|
||
|
void SetRadius( float flRadius );
|
||
|
|
||
|
DECLARE_DATADESC();
|
||
|
|
||
|
int m_iNumElements;
|
||
|
bool m_bInitialized;
|
||
|
int m_iBatchStart;
|
||
|
Vector m_vecCentroid;
|
||
|
float m_flMinElementDist;
|
||
|
|
||
|
CUtlVector<CHandle< CBlobElement > >m_Elements;
|
||
|
|
||
|
DEFINE_CUSTOM_AI;
|
||
|
|
||
|
public:
|
||
|
void InputFormPathShape( inputdata_t &inputdata );
|
||
|
void InputSetRadius( inputdata_t &inputdata );
|
||
|
void InputChaseEntity( inputdata_t &inputdata );
|
||
|
void InputIsolateElement( inputdata_t &inputdata );
|
||
|
void InputFormHemisphere( inputdata_t &inputdata );
|
||
|
void InputFormTwoSpheres( inputdata_t &inputdata );
|
||
|
|
||
|
public:
|
||
|
Vector m_vecAvoidOrigin[ BLOB_MAX_AVOID_ORIGINS ];
|
||
|
float m_flAvoidRadiusSqr;
|
||
|
|
||
|
private:
|
||
|
int m_iReconfigureElement;
|
||
|
int m_iNumAvoidOrigins;
|
||
|
|
||
|
bool m_bEatCombineHack;
|
||
|
};
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( npc_blob, CNPC_Blob );
|
||
|
IMPLEMENT_CUSTOM_AI( npc_blob,CNPC_Blob );
|
||
|
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
// Save/Restore
|
||
|
//---------------------------------------------------------
|
||
|
BEGIN_DATADESC( CNPC_Blob )
|
||
|
|
||
|
DEFINE_FIELD( m_iNumElements, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_bInitialized, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_iBatchStart, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_vecCentroid, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( m_flMinElementDist, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_iReconfigureElement, FIELD_INTEGER ),
|
||
|
DEFINE_UTLVECTOR( m_Elements, FIELD_EHANDLE ),
|
||
|
|
||
|
DEFINE_INPUTFUNC( FIELD_STRING, "FormPathShape", InputFormPathShape ),
|
||
|
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetRadius", InputSetRadius ),
|
||
|
DEFINE_INPUTFUNC( FIELD_STRING, "ChaseEntity", InputChaseEntity ),
|
||
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "IsolateElement", InputIsolateElement ),
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "FormHemisphere", InputFormHemisphere ),
|
||
|
DEFINE_INPUTFUNC( FIELD_VOID, "FormTwoSpheres", InputFormTwoSpheres ),
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
//---------------------------------------------------------
|
||
|
//---------------------------------------------------------
|
||
|
CNPC_Blob::CNPC_Blob()
|
||
|
{
|
||
|
m_iNumElements = 0;
|
||
|
m_bInitialized = false;
|
||
|
m_iBatchStart = 0;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Initialize the custom schedules
|
||
|
// Input :
|
||
|
// Output :
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InitCustomSchedules(void)
|
||
|
{
|
||
|
INIT_CUSTOM_AI(CNPC_Blob);
|
||
|
|
||
|
ADD_CUSTOM_TASK(CNPC_Blob, TASK_MYCUSTOMTASK);
|
||
|
|
||
|
ADD_CUSTOM_SCHEDULE(CNPC_Blob, SCHED_MYCUSTOMSCHEDULE);
|
||
|
|
||
|
ADD_CUSTOM_CONDITION(CNPC_Blob, COND_MYCUSTOMCONDITION);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::Precache( void )
|
||
|
{
|
||
|
PrecacheModel( NPC_BLOB_MODEL );
|
||
|
UTIL_PrecacheOther( "blob_element" );
|
||
|
|
||
|
BaseClass::Precache();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::Spawn( void )
|
||
|
{
|
||
|
Precache();
|
||
|
|
||
|
SetModel( NPC_BLOB_MODEL );
|
||
|
|
||
|
SetHullType(HULL_TINY);
|
||
|
SetHullSizeNormal();
|
||
|
|
||
|
SetSolid( SOLID_NONE );
|
||
|
AddSolidFlags( FSOLID_NOT_STANDABLE );
|
||
|
SetMoveType( MOVETYPE_STEP );
|
||
|
SetBloodColor( BLOOD_COLOR_RED );
|
||
|
m_iHealth = INT_MAX;
|
||
|
m_flFieldOfView = -1.0f;
|
||
|
m_NPCState = NPC_STATE_NONE;
|
||
|
|
||
|
CapabilitiesClear();
|
||
|
CapabilitiesAdd( bits_CAP_MOVE_GROUND );
|
||
|
|
||
|
m_Elements.RemoveAll();
|
||
|
|
||
|
NPCInit();
|
||
|
|
||
|
AddEffects( EF_NODRAW );
|
||
|
|
||
|
m_flMinElementDist = blob_mindist.GetFloat();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//
|
||
|
//
|
||
|
// Output :
|
||
|
//-----------------------------------------------------------------------------
|
||
|
Class_T CNPC_Blob::Classify( void )
|
||
|
{
|
||
|
return CLASS_PLAYER_ALLY;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::RunAI()
|
||
|
{
|
||
|
BaseClass::RunAI();
|
||
|
|
||
|
if( !m_bInitialized )
|
||
|
{
|
||
|
// m_bInitialized is set to false in the constructor. So this bit of
|
||
|
// code runs one time, the first time I think.
|
||
|
Msg("I need to initialize\n");
|
||
|
InitializeElements();
|
||
|
m_bInitialized = true;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
int iIdealNumElements = blob_numelements.GetInt();
|
||
|
if( iIdealNumElements != m_iNumElements )
|
||
|
{
|
||
|
int delta = iIdealNumElements - m_iNumElements;
|
||
|
|
||
|
if( delta < 0 )
|
||
|
{
|
||
|
delta = -delta;
|
||
|
delta = MIN(delta, 5 );
|
||
|
RemoveExcessElements( delta );
|
||
|
|
||
|
if( m_iReconfigureElement > m_iNumElements )
|
||
|
{
|
||
|
// Start this index over at zero, if it is past the new end of the utlvector.
|
||
|
m_iReconfigureElement = 0;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
delta = MIN(delta, 5 );
|
||
|
AddNewElements( delta );
|
||
|
}
|
||
|
|
||
|
RecomputeIdealElementDist();
|
||
|
}
|
||
|
|
||
|
ComputeCentroid();
|
||
|
|
||
|
if( npc_blob_show_centroid.GetBool() )
|
||
|
{
|
||
|
NDebugOverlay::Cross3D( m_vecCentroid + Vector( 0, 0, 12 ), 32, 0, 255, 0, false, 0.025f );
|
||
|
}
|
||
|
|
||
|
if( npc_blob_use_threading.GetBool() )
|
||
|
{
|
||
|
IterRangeParallel( this, &CNPC_Blob::DoBlobBatchedAI, 0, m_Elements.Count() );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DoBlobBatchedAI( 0, m_Elements.Count() );
|
||
|
}
|
||
|
|
||
|
if( GetEnemy() != NULL )
|
||
|
{
|
||
|
float flEnemyDistSqr = m_vecCentroid.DistToSqr( GetEnemy()->GetAbsOrigin() );
|
||
|
|
||
|
if( flEnemyDistSqr <= Square( 32.0f ) )
|
||
|
{
|
||
|
if( GetEnemy()->Classify() == CLASS_COMBINE )
|
||
|
{
|
||
|
if( !m_bEatCombineHack )
|
||
|
{
|
||
|
variant_t var;
|
||
|
|
||
|
var.SetFloat( 0 );
|
||
|
g_EventQueue.AddEvent( GetEnemy(), "HitByBugBait", 0.0f, this, this );
|
||
|
g_EventQueue.AddEvent( GetEnemy(), "SetHealth", var, 3.0f, this, this );
|
||
|
m_bEatCombineHack = true;
|
||
|
|
||
|
blob_radius.SetValue( 48.0f );
|
||
|
RecomputeIdealElementDist();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CTakeDamageInfo info;
|
||
|
|
||
|
info.SetAttacker( this );
|
||
|
info.SetInflictor( this );
|
||
|
info.SetDamage( 5 );
|
||
|
info.SetDamageType( DMG_SLASH );
|
||
|
info.SetDamageForce( Vector( 0, 0, 1 ) );
|
||
|
|
||
|
GetEnemy()->TakeDamage( info );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime + npc_blob_think_interval.GetFloat() );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::GatherConditions( void )
|
||
|
{
|
||
|
if( m_bEatCombineHack )
|
||
|
{
|
||
|
// We just ate someone.
|
||
|
if( !GetEnemy() || !GetEnemy()->IsAlive() )
|
||
|
{
|
||
|
m_bEatCombineHack = false;
|
||
|
blob_radius.SetValue( 160.0f );
|
||
|
RecomputeIdealElementDist();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
BaseClass::GatherConditions();
|
||
|
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Either stand still or chase the enemy, for now.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CNPC_Blob::SelectSchedule( void )
|
||
|
{
|
||
|
if( GetEnemy() == NULL )
|
||
|
return SCHED_IDLE_STAND;
|
||
|
|
||
|
return SCHED_CHASE_ENEMY;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Average the origin of all elements to get the centroid for the group
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::ComputeCentroid()
|
||
|
{
|
||
|
m_vecCentroid = vec3_origin;
|
||
|
|
||
|
for( int i = 0 ; i < m_Elements.Count() ; i++ )
|
||
|
{
|
||
|
m_vecCentroid += m_Elements[ i ]->GetAbsOrigin();
|
||
|
}
|
||
|
|
||
|
m_vecCentroid /= m_Elements.Count();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Run all of the AI for elements within the range iStart to iEnd
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::DoBlobBatchedAI( int iStart, int iEnd )
|
||
|
{
|
||
|
float flInterval = gpGlobals->curtime - GetLastThink();
|
||
|
|
||
|
// Local fields for sin-wave movement variance
|
||
|
float flMySine;
|
||
|
float flAmplitude = npc_blob_sin_amplitude.GetFloat();
|
||
|
float flMyAmplitude;
|
||
|
Vector vecRight;
|
||
|
Vector vecForward;
|
||
|
|
||
|
// Local fields for attract/repel
|
||
|
float minDistSqr = Square( m_flMinElementDist );
|
||
|
float flBlobSpeed = blob_element_speed.GetFloat();
|
||
|
float flSpeed;
|
||
|
|
||
|
// Local fields for speed limiting
|
||
|
float flMinSpeed = blob_element_speed.GetFloat() * 0.5f;
|
||
|
float flMaxSpeed = blob_element_speed.GetFloat() * 1.5f;
|
||
|
bool bEnforceSpeedLimit;
|
||
|
bool bEnforceRelativePositions;
|
||
|
bool bDoMovementVariation;
|
||
|
bool bDoOrientation = npc_blob_use_orientation.GetBool();
|
||
|
float flIdleSpeedFactor = npc_blob_idle_speed_factor.GetFloat();
|
||
|
|
||
|
// Group cohesion
|
||
|
float flBlobRadiusSqr = Square( blob_radius.GetFloat() + 48.0f ); // Four feet of fudge
|
||
|
|
||
|
// Build a right-hand vector along which we'll add some sine wave data to give each
|
||
|
// element a unique insect-like undulation along an axis perpendicular to their path,
|
||
|
// which makes the entire group look far less orderly
|
||
|
if( GetEnemy() != NULL )
|
||
|
{
|
||
|
// If I have an enemy, the right-hand vector is perpendicular to a straight line
|
||
|
// from the group's centroid to the enemy's origin.
|
||
|
vecForward = GetEnemy()->GetAbsOrigin() - m_vecCentroid;
|
||
|
VectorNormalize( vecForward );
|
||
|
vecRight.x = vecForward.y;
|
||
|
vecRight.y = -vecForward.x;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// If there is no enemy, wobble along the axis from the centroid to me.
|
||
|
vecForward = GetAbsOrigin() - m_vecCentroid;
|
||
|
VectorNormalize( vecForward );
|
||
|
vecRight.x = vecForward.y;
|
||
|
vecRight.y = -vecForward.x;
|
||
|
}
|
||
|
|
||
|
//--
|
||
|
// MAIN LOOP - Run all of the elements in the set iStart to iEnd
|
||
|
//--
|
||
|
for( int i = iStart ; i < iEnd ; i++ )
|
||
|
{
|
||
|
CBlobElement *pThisElement = m_Elements[ i ];
|
||
|
|
||
|
//--
|
||
|
// Initial movement
|
||
|
//--
|
||
|
// Start out with bEnforceSpeedLimit set to false. This is because an element
|
||
|
// can't overspeed if it's moving undisturbed towards its target entity or
|
||
|
// target location. An element can only under or overspeed when it is repelled
|
||
|
// by multiple other elements in the group. See "Relative Positions" below.
|
||
|
//
|
||
|
// Initialize some 'defaults' that may be changed for each iteration of this loop
|
||
|
bEnforceSpeedLimit = false;
|
||
|
bEnforceRelativePositions = true;
|
||
|
bDoMovementVariation = true;
|
||
|
flSpeed = flBlobSpeed;
|
||
|
|
||
|
switch( pThisElement->GetActiveMovementRule() )
|
||
|
{
|
||
|
case BLOB_MOVE_DONT_MOVE:
|
||
|
{
|
||
|
pThisElement->SetElementVelocity( vec3_origin, true );
|
||
|
|
||
|
trace_t tr;
|
||
|
Vector vecOrigin = pThisElement->GetAbsOrigin();
|
||
|
|
||
|
UTIL_TraceLine( vecOrigin, vecOrigin - Vector( 0, 0, 16), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
||
|
|
||
|
if( tr.fraction < 1.0f )
|
||
|
{
|
||
|
QAngle angles;
|
||
|
|
||
|
VectorAngles( tr.plane.normal, angles );
|
||
|
|
||
|
float flSwap = angles.x;
|
||
|
|
||
|
angles.x = -angles.y;
|
||
|
angles.y = flSwap;
|
||
|
|
||
|
pThisElement->SetAbsAngles( angles );
|
||
|
}
|
||
|
}
|
||
|
continue;
|
||
|
break;
|
||
|
|
||
|
case BLOB_MOVE_TO_TARGET_LOCATION:
|
||
|
{
|
||
|
Vector vecDiff = pThisElement->GetAbsOrigin() - pThisElement->m_vecTargetLocation;
|
||
|
|
||
|
if( vecDiff.Length2DSqr() <= Square(80.0f) )
|
||
|
{
|
||
|
// Don't shove this guy around any more, let him get to his goal position.
|
||
|
flSpeed *= 0.5f;
|
||
|
bEnforceRelativePositions = false;
|
||
|
bDoMovementVariation = false;
|
||
|
}
|
||
|
|
||
|
pThisElement->MoveTowardsTargetLocation( flSpeed );
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case BLOB_MOVE_TO_TARGET_ENTITY:
|
||
|
{
|
||
|
if( !IsMoving() && GetEnemy() == NULL )
|
||
|
{
|
||
|
if( pThisElement->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) <= flBlobRadiusSqr )
|
||
|
{
|
||
|
flSpeed = (flSpeed * flIdleSpeedFactor) * pThisElement->m_flRandomEightyPercent;
|
||
|
}
|
||
|
}
|
||
|
pThisElement->MoveTowardsTargetEntity( flSpeed );
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Msg("ERROR: Blob Element with unspecified Movement Rule\n");
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//---
|
||
|
// Relative positions
|
||
|
//--
|
||
|
// Check this element against ALL other elements. If the two elements are closer
|
||
|
// than the allowed minimum distance, repel this element away. (The other element
|
||
|
// will repel when its AI runs). A single element can be repelled by many other
|
||
|
// elements. This is why bEnforceSpeedLimit is set to true if any of the repelling
|
||
|
// code runs for this element. Multiple attempts to repel an element in the same
|
||
|
// direction will cause overspeed. Conflicting attempts to repel an element in opposite
|
||
|
// directions will cause underspeed.
|
||
|
Vector vecDir = Vector( 0, 0, 0 );
|
||
|
Vector vecThisElementOrigin = pThisElement->GetAbsOrigin();
|
||
|
|
||
|
if( bEnforceRelativePositions )
|
||
|
{
|
||
|
for( int j = 0 ; j < m_Elements.Count() ; j++ )
|
||
|
{
|
||
|
// This is the innermost loop! We should optimize here, if anywhere.
|
||
|
|
||
|
// If this element is on the wall, then don't be repelled by anyone. Repelling
|
||
|
// elements that are trying to climb a wall usually make them look like they
|
||
|
// fall off the wall a few times while climbing.
|
||
|
if( pThisElement->m_bOnWall )
|
||
|
continue;
|
||
|
|
||
|
CBlobElement *pThatElement = m_Elements[ j ];
|
||
|
if( i != j )
|
||
|
{
|
||
|
Vector vecThatElementOrigin = pThatElement->GetAbsOrigin();
|
||
|
float distSqr = vecThisElementOrigin.DistToSqr( vecThatElementOrigin );
|
||
|
|
||
|
if( distSqr < minDistSqr )
|
||
|
{
|
||
|
// Too close to the other element. Move away.
|
||
|
float flRepelSpeed;
|
||
|
Vector vecRepelDir = ( vecThisElementOrigin - vecThatElementOrigin );
|
||
|
|
||
|
vecRepelDir.NormalizeInPlace();
|
||
|
flRepelSpeed = (flSpeed * ( 1.0f - ( distSqr / minDistSqr ) ) ) * pThatElement->GetSinePhase();
|
||
|
pThisElement->AddElementVelocity( vecRepelDir * flRepelSpeed, true );
|
||
|
|
||
|
// Since we altered this element's velocity after it was initially set, there's a chance
|
||
|
// that the sums of multiple vectors will cause the element to over or underspeed, so
|
||
|
// mark it for speed limit enforcement
|
||
|
bEnforceSpeedLimit = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//--
|
||
|
// Movement variation
|
||
|
//--
|
||
|
if( bDoMovementVariation )
|
||
|
{
|
||
|
flMySine = sin( gpGlobals->curtime * pThisElement->GetSineFrequency() );
|
||
|
flMyAmplitude = flAmplitude * pThisElement->GetSineAmplitude();
|
||
|
pThisElement->AddElementVelocity( vecRight * (flMySine * flMyAmplitude), true );
|
||
|
}
|
||
|
|
||
|
// Avoidance
|
||
|
for( int a = 0 ; a < m_iNumAvoidOrigins ; a++ )
|
||
|
{
|
||
|
Vector vecAvoidDir = pThisElement->GetAbsOrigin() - m_vecAvoidOrigin[ a ];
|
||
|
|
||
|
if( vecAvoidDir.LengthSqr() <= (m_flAvoidRadiusSqr * pThisElement->m_flRandomEightyPercent) )
|
||
|
{
|
||
|
VectorNormalize( vecAvoidDir );
|
||
|
pThisElement->AddElementVelocity( vecAvoidDir * (flSpeed * 2.0f), true );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//--
|
||
|
// Speed limits
|
||
|
//---
|
||
|
if( bEnforceSpeedLimit == true )
|
||
|
{
|
||
|
pThisElement->EnforceSpeedLimits( flMinSpeed, flMaxSpeed );
|
||
|
}
|
||
|
|
||
|
//--
|
||
|
// Wall crawling
|
||
|
//--
|
||
|
pThisElement->ModifyVelocityForSurface( flInterval, flSpeed );
|
||
|
|
||
|
// For identifying stuck elements.
|
||
|
pThisElement->m_vecPrevOrigin = pThisElement->GetAbsOrigin();
|
||
|
|
||
|
pThisElement->m_flDistFromCentroidSqr = pThisElement->m_vecPrevOrigin.DistToSqr( m_vecCentroid );
|
||
|
|
||
|
// Orientation
|
||
|
if( bDoOrientation )
|
||
|
{
|
||
|
QAngle angles;
|
||
|
VectorAngles( pThisElement->GetAbsVelocity(), angles );
|
||
|
pThisElement->SetAbsAngles( angles );
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
//--
|
||
|
// Stragglers/Group integrity
|
||
|
//
|
||
|
if( pThisElement->m_flDistFromCentroidSqr > flStragglerDistSqr )
|
||
|
{
|
||
|
NDebugOverlay::Line( pThisElement->GetAbsOrigin(), m_vecCentroid, 255, 0, 0, false, 0.025f );
|
||
|
}
|
||
|
*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Throw out all elements and their entities except for the the specified
|
||
|
// index into the UTILVector. This is useful for isolating elements that
|
||
|
// get into a bad state.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::RemoveAllElementsExcept( int iExempt )
|
||
|
{
|
||
|
if( m_Elements.Count() == 1 )
|
||
|
return;
|
||
|
|
||
|
m_Elements[ 0 ].Set( m_Elements[ iExempt ].Get() );
|
||
|
|
||
|
for( int i = 1 ; i < m_Elements.Count() ; i++ )
|
||
|
{
|
||
|
if( i != iExempt )
|
||
|
{
|
||
|
m_Elements[ i ]->SUB_Remove();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_Elements.RemoveMultiple( 1, m_Elements.Count() - 1 );
|
||
|
|
||
|
m_iNumElements = 1;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: The blob has too many elements. Locate good candidates and remove
|
||
|
// this many elements.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::RemoveExcessElements( int iNumElements )
|
||
|
{
|
||
|
// For now we're not assessing candidates, just blindly removing.
|
||
|
int i;
|
||
|
for( i = 0 ; i < iNumElements ; i++ )
|
||
|
{
|
||
|
int iLastElement = m_iNumElements - 1;
|
||
|
|
||
|
// Nuke the associated entity
|
||
|
m_Elements[ iLastElement ]->SUB_Remove();
|
||
|
|
||
|
m_Elements.Remove( iLastElement );
|
||
|
m_iNumElements--;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: This blob has too few elements. Add this many elements by stacking
|
||
|
// them on top of existing elements and allowing them to disperse themselves
|
||
|
// into the blob.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::AddNewElements( int iNumElements )
|
||
|
{
|
||
|
int i;
|
||
|
|
||
|
// Keep track of how many elements we had when we came into this function.
|
||
|
// Since the new elements copy their origins from existing elements, we only want
|
||
|
// to copy origins from elements that existed before we came into this function.
|
||
|
// Otherwise, the more elements we create while in this function, the more likely it
|
||
|
// becomes that several of them will stack on the same origin.
|
||
|
int iInitialElements = m_iNumElements;
|
||
|
|
||
|
for( i = 0 ; i < iNumElements ; i++ )
|
||
|
{
|
||
|
CBlobElement *pElement = CreateNewElement();
|
||
|
|
||
|
if( pElement != NULL )
|
||
|
{
|
||
|
// Copy the origin of some element that is not me. This will make the expansion
|
||
|
// of the group easier on the eye, since this element will spawn inside of some
|
||
|
// other element, and then be pushed out by the blob's repel rules.
|
||
|
int iCopyElement = random->RandomInt( 0, iInitialElements - 1 );
|
||
|
pElement->SetAbsOrigin( m_Elements[iCopyElement]->GetAbsOrigin() );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
#define BLOB_MAX_VERTS 128
|
||
|
void CNPC_Blob::FormShapeFromPath( string_t iszPathName )
|
||
|
{
|
||
|
Vector vertex[ BLOB_MAX_VERTS ];
|
||
|
|
||
|
int i;
|
||
|
int iNumVerts = 0;
|
||
|
|
||
|
for ( i = 0 ; i < BLOB_MAX_VERTS ; i++ )
|
||
|
{
|
||
|
if( iszPathName == NULL_STRING )
|
||
|
{
|
||
|
//Msg("Terminal path\n");
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, iszPathName );
|
||
|
|
||
|
if( pEntity != NULL )
|
||
|
{
|
||
|
bool bClosedPath = false;
|
||
|
|
||
|
for( int j = 0 ; j < i ; j++ )
|
||
|
{
|
||
|
// Stop if we reach a vertex that's already in the array (closed path)
|
||
|
if( vertex[ j ] == pEntity->GetAbsOrigin() )
|
||
|
{
|
||
|
//Msg("Closed path!\n");
|
||
|
bClosedPath = true;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
vertex[ i ] = pEntity->GetAbsOrigin();
|
||
|
iszPathName = pEntity->m_target;
|
||
|
iNumVerts++;
|
||
|
|
||
|
if( bClosedPath )
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//Msg("%d verts found in path!\n", iNumVerts);
|
||
|
|
||
|
float flPathLength = 0.0f;
|
||
|
float flDistribution;
|
||
|
|
||
|
for( i = 0 ; i < iNumVerts - 1 ; i++ )
|
||
|
{
|
||
|
Vector vecDiff = vertex[ i ] - vertex[ i + 1 ];
|
||
|
|
||
|
flPathLength += vecDiff.Length();
|
||
|
}
|
||
|
|
||
|
flDistribution = flPathLength / m_iNumElements;
|
||
|
Msg("Path length is %f, distribution is %f\n", flPathLength, flDistribution );
|
||
|
|
||
|
int element = 0;
|
||
|
for( i = 0 ; i < iNumVerts - 1 ; i++ )
|
||
|
{
|
||
|
//NDebugOverlay::Line( vertex[ i ], vertex[ i + 1 ], 0, 255, 0, false, 10.0f );
|
||
|
Vector vecDiff = vertex[ i + 1 ] - vertex[ i ];
|
||
|
Vector vecStart = vertex[ i ];
|
||
|
|
||
|
float flSegmentLength = VectorNormalize( vecDiff );
|
||
|
|
||
|
float flStep;
|
||
|
|
||
|
for( flStep = 0.0f ; flStep < flSegmentLength ; flStep += flDistribution )
|
||
|
{
|
||
|
//NDebugOverlay::Cross3D( vecStart + vecDiff * flStep, 16, 255, 255, 255, false, 10.0f );
|
||
|
m_Elements[ element ]->SetTargetLocation( vecStart + vecDiff * flStep );
|
||
|
m_Elements[ element ]->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_LOCATION );
|
||
|
element++;
|
||
|
|
||
|
if( element == m_iNumElements )
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::SetRadius( float flRadius )
|
||
|
{
|
||
|
blob_radius.SetValue( flRadius );
|
||
|
RecomputeIdealElementDist();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputFormPathShape( inputdata_t &inputdata )
|
||
|
{
|
||
|
string_t shape = inputdata.value.StringID();
|
||
|
|
||
|
if( shape == NULL_STRING )
|
||
|
return;
|
||
|
|
||
|
//Msg("I'm supposed to form some shape called:%s\n", shape );
|
||
|
|
||
|
FormShapeFromPath( shape );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputSetRadius( inputdata_t &inputdata )
|
||
|
{
|
||
|
float flNewRadius = inputdata.value.Float();
|
||
|
|
||
|
SetRadius( flNewRadius );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputChaseEntity( inputdata_t &inputdata )
|
||
|
{
|
||
|
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, inputdata.value.StringID(), NULL, inputdata.pActivator, inputdata.pCaller );
|
||
|
|
||
|
if ( pEntity )
|
||
|
{
|
||
|
for( int i = 0 ; i < m_Elements.Count() ; i++ )
|
||
|
{
|
||
|
CBlobElement *pElement = m_Elements[ i ];
|
||
|
|
||
|
pElement->SetTargetEntity( pEntity );
|
||
|
pElement->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_ENTITY );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputIsolateElement( inputdata_t &inputdata )
|
||
|
{
|
||
|
int iElement = inputdata.value.Int();
|
||
|
|
||
|
RemoveAllElementsExcept( iElement );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputFormHemisphere( inputdata_t &inputdata )
|
||
|
{
|
||
|
Vector center = GetAbsOrigin();
|
||
|
const float flRadius = 240.0f;
|
||
|
|
||
|
Vector vecDir;
|
||
|
|
||
|
for( int i = 0 ; i < m_Elements.Count() ; i++ )
|
||
|
{
|
||
|
CBlobElement *pElement = m_Elements[ i ];
|
||
|
|
||
|
// Compute a point around my center
|
||
|
vecDir.x = random->RandomFloat( -1, 1 );
|
||
|
vecDir.y = random->RandomFloat( -1, 1 );
|
||
|
vecDir.z = random->RandomFloat( 0, 1 );
|
||
|
|
||
|
VectorNormalize( vecDir );
|
||
|
|
||
|
pElement->SetTargetLocation( center + vecDir * flRadius );
|
||
|
pElement->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_LOCATION );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InputFormTwoSpheres( inputdata_t &inputdata )
|
||
|
{
|
||
|
Vector center = GetAbsOrigin();
|
||
|
Vector sphere1 = GetAbsOrigin() + Vector( 120.0f, 0, 120.0f );
|
||
|
Vector sphere2 = GetAbsOrigin() + Vector( -120.0f, 0, 120.0f );
|
||
|
const float flRadius = 100.0f;
|
||
|
|
||
|
Vector vecDir;
|
||
|
|
||
|
int batchSize = m_Elements.Count() / 2;
|
||
|
|
||
|
for( int i = 0 ; i < batchSize ; i++ )
|
||
|
{
|
||
|
CBlobElement *pElement = m_Elements[ i ];
|
||
|
|
||
|
// Compute a point around my center
|
||
|
vecDir.x = random->RandomFloat( -1, 1 );
|
||
|
vecDir.y = random->RandomFloat( -1, 1 );
|
||
|
vecDir.z = random->RandomFloat( -1, 1 );
|
||
|
|
||
|
VectorNormalize( vecDir );
|
||
|
|
||
|
pElement->SetTargetLocation( sphere1 + vecDir * flRadius );
|
||
|
pElement->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_LOCATION );
|
||
|
}
|
||
|
|
||
|
for( int i = batchSize ; i < m_Elements.Count() ; i++ )
|
||
|
{
|
||
|
CBlobElement *pElement = m_Elements[ i ];
|
||
|
|
||
|
// Compute a point around my center
|
||
|
vecDir.x = random->RandomFloat( -1, 1 );
|
||
|
vecDir.y = random->RandomFloat( -1, 1 );
|
||
|
vecDir.z = random->RandomFloat( -1, 1 );
|
||
|
|
||
|
VectorNormalize( vecDir );
|
||
|
|
||
|
pElement->SetTargetLocation( sphere2 + vecDir * flRadius );
|
||
|
pElement->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_LOCATION );
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Get the index of the element to start processing with for this batch.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CNPC_Blob::GetBatchStart()
|
||
|
{
|
||
|
return m_iBatchStart;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Get the index of the element to stop processing with for this batch.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CNPC_Blob::GetBatchEnd()
|
||
|
{
|
||
|
int batchDone = m_iBatchStart + ComputeBatchSize();
|
||
|
batchDone = MIN( batchDone, m_Elements.Count() );
|
||
|
|
||
|
return batchDone;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
int CNPC_Blob::ComputeBatchSize()
|
||
|
{
|
||
|
int batchSize = m_Elements.Count() / ( 100 / blob_batchpercent.GetInt() );
|
||
|
return batchSize;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
|
||
|
void CNPC_Blob::AdvanceBatch()
|
||
|
{
|
||
|
m_iBatchStart += ComputeBatchSize();
|
||
|
|
||
|
if( m_iBatchStart >= m_Elements.Count() )
|
||
|
m_iBatchStart = 0;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Creates a new blob element from scratch and adds it to the blob
|
||
|
//-----------------------------------------------------------------------------
|
||
|
CBlobElement *CNPC_Blob::CreateNewElement()
|
||
|
{
|
||
|
CBlobElement *pElement = static_cast<CBlobElement*>(CreateEntityByName( "blob_element" ));
|
||
|
|
||
|
if( pElement != NULL )
|
||
|
{
|
||
|
pElement->SetOwnerEntity( this );
|
||
|
pElement->SetSinePhase( fabs( sin(((float)m_iNumElements)/10.0f) ) );
|
||
|
pElement->SetActiveMovementRule( BLOB_MOVE_TO_TARGET_ENTITY );
|
||
|
pElement->SetTargetEntity( this );
|
||
|
|
||
|
pElement->m_iElementNumber = m_iNumElements;
|
||
|
m_iNumElements++;
|
||
|
pElement->Spawn();
|
||
|
m_Elements.AddToTail( pElement );
|
||
|
return pElement;
|
||
|
}
|
||
|
|
||
|
Warning("Blob could not spawn new element!\n");
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Create, initialize, and distribute all blob elements
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::InitializeElements()
|
||
|
{
|
||
|
// Squirt all of the elements out into a circle
|
||
|
int i;
|
||
|
QAngle angDistributor( 0, 0, 0 );
|
||
|
|
||
|
int iNumElements = blob_numelements.GetInt();
|
||
|
|
||
|
float step = 360.0f / ((float)iNumElements);
|
||
|
for( i = 0 ; i < iNumElements ; i++ )
|
||
|
{
|
||
|
Vector vecDir;
|
||
|
Vector vecDest;
|
||
|
AngleVectors( angDistributor, &vecDir, NULL, NULL );
|
||
|
vecDest = WorldSpaceCenter() + vecDir * 64.0f;
|
||
|
|
||
|
CBlobElement *pElement = CreateNewElement();
|
||
|
|
||
|
if( !pElement )
|
||
|
{
|
||
|
Msg("Blob could not create all elements!!\n");
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
trace_t tr;
|
||
|
UTIL_TraceLine( vecDest, vecDest + Vector (0, 0, MIN_COORD_FLOAT), MASK_SHOT, pElement, COLLISION_GROUP_NONE, &tr );
|
||
|
|
||
|
pElement->SetAbsOrigin( tr.endpos + Vector( 0, 0, 1 ) );
|
||
|
|
||
|
angDistributor.y += step;
|
||
|
}
|
||
|
|
||
|
CBaseEntity *pEntity = gEntList.FindEntityByClassname( NULL, "info_target" );
|
||
|
for( i = 0 ; i < BLOB_MAX_AVOID_ORIGINS ; i++ )
|
||
|
{
|
||
|
if( pEntity )
|
||
|
{
|
||
|
if( pEntity->NameMatches("avoid") )
|
||
|
{
|
||
|
m_vecAvoidOrigin[ i ] = pEntity->GetAbsOrigin();
|
||
|
m_flAvoidRadiusSqr = Square( 120.0f );
|
||
|
m_iNumAvoidOrigins++;
|
||
|
}
|
||
|
|
||
|
pEntity = gEntList.FindEntityByClassname( pEntity, "info_target" );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Msg("%d avoid origins\n", m_iNumAvoidOrigins );
|
||
|
|
||
|
RecomputeIdealElementDist();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CNPC_Blob::RecomputeIdealElementDist()
|
||
|
{
|
||
|
float radius = blob_radius.GetFloat();
|
||
|
float area = M_PI * Square(radius);
|
||
|
|
||
|
//Msg("Area of blob is: %f\n", area );
|
||
|
|
||
|
//m_flMinElementDist = 2.75f * sqrt( area / m_iNumElements );
|
||
|
m_flMinElementDist = M_PI * sqrt( area / m_iNumElements );
|
||
|
|
||
|
//Msg("New element dist: %f\n", m_flMinElementDist );
|
||
|
}
|
||
|
|