374 lines
11 KiB
C++
374 lines
11 KiB
C++
#include "cbase.h"
|
|
#include "baseentity.h"
|
|
#include "asw_base_spawner.h"
|
|
#include "asw_marine.h"
|
|
#include "asw_gamerules.h"
|
|
#include "asw_marine_resource.h"
|
|
#include "asw_game_resource.h"
|
|
#include "entityapi.h"
|
|
#include "entityoutput.h"
|
|
#include "props.h"
|
|
#include "asw_alien.h"
|
|
#include "asw_director.h"
|
|
#include "asw_fail_advice.h"
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar asw_debug_spawners("asw_debug_spawners", "0", FCVAR_CHEAT, "Displays debug messages for the asw_spawners");
|
|
|
|
BEGIN_DATADESC( CASW_Base_Spawner )
|
|
DEFINE_KEYFIELD( m_bSpawnIfMarinesAreNear, FIELD_BOOLEAN, "SpawnIfMarinesAreNear" ),
|
|
DEFINE_KEYFIELD( m_flNearDistance, FIELD_FLOAT, "NearDistance" ),
|
|
DEFINE_KEYFIELD( m_AlienOrders, FIELD_INTEGER, "AlienOrders" ),
|
|
DEFINE_KEYFIELD( m_AlienOrderTargetName, FIELD_STRING, "AlienOrderTargetName" ),
|
|
DEFINE_KEYFIELD( m_AlienName, FIELD_STRING, "AlienNameTag" ),
|
|
DEFINE_KEYFIELD( m_bStartBurrowed, FIELD_BOOLEAN, "StartBurrowed" ),
|
|
DEFINE_KEYFIELD( m_UnburrowIdleActivity, FIELD_STRING, "UnburrowIdleActivity" ),
|
|
DEFINE_KEYFIELD( m_UnburrowActivity, FIELD_STRING, "UnburrowActivity" ),
|
|
DEFINE_KEYFIELD( m_bCheckSpawnIsClear, FIELD_BOOLEAN, "ClearCheck" ),
|
|
DEFINE_KEYFIELD( m_bLongRangeNPC, FIELD_BOOLEAN, "LongRange" ),
|
|
DEFINE_KEYFIELD( m_iMinSkillLevel, FIELD_INTEGER, "MinSkillLevel" ),
|
|
DEFINE_KEYFIELD( m_iMaxSkillLevel, FIELD_INTEGER, "MaxSkillLevel" ),
|
|
|
|
DEFINE_OUTPUT( m_OnSpawned, "OnSpawned" ),
|
|
|
|
DEFINE_FIELD( m_iMoveAsideCount, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_hAlienOrderTarget, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "ToggleEnabled", InputToggleEnabled ),
|
|
END_DATADESC()
|
|
|
|
CASW_Base_Spawner::CASW_Base_Spawner()
|
|
{
|
|
m_hAlienOrderTarget = NULL;
|
|
m_flLastSpawnTime = 0.0f;
|
|
m_bEnabled = true;
|
|
}
|
|
|
|
CASW_Base_Spawner::~CASW_Base_Spawner()
|
|
{
|
|
|
|
}
|
|
|
|
void CASW_Base_Spawner::Spawn()
|
|
{
|
|
SetSolid( SOLID_NONE );
|
|
m_iMoveAsideCount = 0;
|
|
Precache();
|
|
//SetModel( "models/editor/asw_spawner/asw_spawner.mdl" );
|
|
}
|
|
|
|
void CASW_Base_Spawner::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
|
|
PrecacheScriptSound( "Spawner.Horde" );
|
|
PrecacheScriptSound( "Spawner.AreaClear" );
|
|
//PrecacheModel( "models/editor/asw_spawner/asw_spawner.mdl" );
|
|
}
|
|
|
|
bool CASW_Base_Spawner::CanSpawn( const Vector &vecHullMins, const Vector &vecHullMaxs )
|
|
{
|
|
if ( !m_bEnabled )
|
|
return false;
|
|
|
|
// is a marine too near?
|
|
if ( !m_bSpawnIfMarinesAreNear && m_flNearDistance > 0 )
|
|
{
|
|
CASW_Game_Resource* pGameResource = ASWGameResource();
|
|
float distance = 0.0f;
|
|
for ( int i = 0; i < ASW_MAX_MARINE_RESOURCES; i++ )
|
|
{
|
|
CASW_Marine_Resource* pMR = pGameResource->GetMarineResource(i);
|
|
if ( pMR && pMR->GetMarineEntity() && pMR->GetMarineEntity()->GetHealth() > 0 )
|
|
{
|
|
distance = pMR->GetMarineEntity()->GetAbsOrigin().DistTo( GetAbsOrigin() );
|
|
if ( distance < m_flNearDistance )
|
|
{
|
|
if ( asw_debug_spawners.GetBool() )
|
|
Msg("asw_spawner(%s): Alien can't spawn because a marine (%d) is %f away\n", GetEntityName(), i, distance);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_iMoveAsideCount > 5)
|
|
{
|
|
// we've tried to move aliens aside 5 times, don't do it anymore, else they'll never go to sleep and save CPU
|
|
return false;
|
|
}
|
|
|
|
Vector mins = GetAbsOrigin() - Vector( 23, 23, 0 );
|
|
Vector maxs = GetAbsOrigin() + Vector( 23, 23, 0 );
|
|
CBaseEntity *pList[128];
|
|
int count = UTIL_EntitiesInBox( pList, 128, mins, maxs, FL_CLIENT|FL_NPC );
|
|
if ( count )
|
|
{
|
|
//Iterate through the list and check the results
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
//Don't build on top of another entity
|
|
if ( pList[i] == NULL )
|
|
continue;
|
|
|
|
//If one of the entities is solid, then we may not be able to spawn now
|
|
if ( ( pList[i]->GetSolidFlags() & FSOLID_NOT_SOLID ) == false )
|
|
{
|
|
// Since the outer method doesn't work well around striders on account of their huge bounding box.
|
|
// Find the ground under me and see if a human hull would fit there.
|
|
trace_t tr;
|
|
UTIL_TraceHull( GetAbsOrigin() + Vector( 0, 0, 1 ),
|
|
GetAbsOrigin() - Vector( 0, 0, 1 ),
|
|
vecHullMins,
|
|
vecHullMaxs,
|
|
MASK_NPCSOLID,
|
|
NULL,
|
|
COLLISION_GROUP_NONE,
|
|
&tr );
|
|
|
|
if (tr.fraction < 1.0f && tr.DidHitNonWorldEntity())
|
|
{
|
|
bool bMovedSomethingAside = false;
|
|
// some non-world entity is blocking the spawn point, so don't spawn
|
|
if (tr.m_pEnt)
|
|
{
|
|
IASW_Spawnable_NPC *pSpawnable = dynamic_cast<IASW_Spawnable_NPC*>(tr.m_pEnt);
|
|
if (pSpawnable)
|
|
{
|
|
pSpawnable->MoveAside(); // try and make him move aside
|
|
bMovedSomethingAside = true;
|
|
}
|
|
if (asw_debug_spawners.GetBool())
|
|
Msg("asw_spawner(%s): Alien can't spawn because a non-world entity is blocking the spawn point: %s\n", GetEntityName(), tr.m_pEnt->GetClassname());
|
|
}
|
|
else
|
|
{
|
|
if (asw_debug_spawners.GetBool())
|
|
Msg("asw_spawner(%s): Alien can't spawn because a non-world entity is blocking the spawn point.\n", GetEntityName());
|
|
}
|
|
|
|
if (bMovedSomethingAside)
|
|
m_iMoveAsideCount++;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// is there something blocking the spawn point?
|
|
if ( m_bCheckSpawnIsClear )
|
|
{
|
|
if ( asw_debug_spawners.GetBool() )
|
|
{
|
|
Msg("Checking spawn is clear...\n");
|
|
}
|
|
|
|
trace_t tr;
|
|
UTIL_TraceHull( GetAbsOrigin(),
|
|
GetAbsOrigin() + Vector( 0, 0, 1 ),
|
|
vecHullMins,
|
|
vecHullMaxs,
|
|
MASK_NPCSOLID,
|
|
this,
|
|
COLLISION_GROUP_NONE,
|
|
&tr );
|
|
|
|
if( tr.fraction != 1.0 )
|
|
{
|
|
if ( asw_debug_spawners.GetBool() )
|
|
Msg("asw_spawner(%s): Alien can't spawn because he wouldn't fit in the spawn point.\n", GetEntityName());
|
|
// TODO: If we were trying to spawn an uber, change to spawning a regular instead
|
|
return false;
|
|
}
|
|
}
|
|
|
|
m_iMoveAsideCount = 0;
|
|
return true;
|
|
}
|
|
|
|
void CASW_Base_Spawner::RemoveObstructingProps( CBaseEntity *pChild )
|
|
{
|
|
// If I'm stuck inside any props, remove them
|
|
bool bFound = true;
|
|
while ( bFound )
|
|
{
|
|
trace_t tr;
|
|
UTIL_TraceHull( pChild->GetAbsOrigin(), pChild->GetAbsOrigin(), pChild->WorldAlignMins(), pChild->WorldAlignMaxs(), MASK_NPCSOLID, pChild, COLLISION_GROUP_NONE, &tr );
|
|
if (asw_debug_spawners.GetBool())
|
|
{
|
|
NDebugOverlay::Box( pChild->GetAbsOrigin(), pChild->WorldAlignMins(), pChild->WorldAlignMaxs(), 0, 255, 0, 32, 5.0 );
|
|
}
|
|
if ( tr.fraction != 1.0 && tr.m_pEnt )
|
|
{
|
|
if ( dynamic_cast<CBaseProp*>(tr.m_pEnt) )
|
|
{
|
|
// Set to non-solid so this loop doesn't keep finding it
|
|
tr.m_pEnt->AddSolidFlags( FSOLID_NOT_SOLID );
|
|
UTIL_RemoveImmediate( tr.m_pEnt );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
bFound = false;
|
|
}
|
|
}
|
|
|
|
CBaseEntity* CASW_Base_Spawner::GetOrderTarget()
|
|
{
|
|
// find entity with name m_AlienOrderTargetName
|
|
if (GetAlienOrderTarget() == NULL &&
|
|
(m_AlienOrders == AOT_MoveTo || m_AlienOrders == AOT_MoveToIgnoringMarines )
|
|
)
|
|
{
|
|
m_hAlienOrderTarget = gEntList.FindEntityByName( NULL, m_AlienOrderTargetName, NULL );
|
|
|
|
if( !GetAlienOrderTarget() )
|
|
{
|
|
DevWarning("%s: asw_spawner can't find order object: %s\n", GetDebugName(), STRING(m_AlienOrderTargetName) );
|
|
return NULL;
|
|
}
|
|
}
|
|
return GetAlienOrderTarget();
|
|
}
|
|
|
|
IASW_Spawnable_NPC* CASW_Base_Spawner::SpawnAlien( const char *szAlienClassName, const Vector &vecHullMins, const Vector &vecHullMaxs )
|
|
{
|
|
if ( !IsValidOnThisSkillLevel() )
|
|
{
|
|
UTIL_Remove(this); // delete ourself if this spawner isn't valid on this difficulty level
|
|
return NULL;
|
|
}
|
|
|
|
if ( !CanSpawn( vecHullMins, vecHullMaxs ) ) // this may turn off m_bCurrentlySpawningUber if there's no room
|
|
return NULL;
|
|
|
|
CBaseEntity *pEntity = CreateEntityByName( szAlienClassName );
|
|
if ( !pEntity )
|
|
{
|
|
Msg( "Failed to spawn %s\n", szAlienClassName );
|
|
return NULL;
|
|
}
|
|
|
|
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer();
|
|
if ( pNPC )
|
|
{
|
|
pNPC->AddSpawnFlags( SF_NPC_FALL_TO_GROUND );
|
|
}
|
|
|
|
// check if he can see far
|
|
if ( m_bLongRangeNPC )
|
|
pEntity->AddSpawnFlags( SF_NPC_LONG_RANGE );
|
|
|
|
if ( HasSpawnFlags( ASW_SF_NEVER_SLEEP ) )
|
|
pEntity->AddSpawnFlags( SF_NPC_ALWAYSTHINK );
|
|
|
|
// Strip pitch and roll from the spawner's angles. Pass only yaw to the spawned NPC.
|
|
QAngle angles = GetAbsAngles();
|
|
angles.x = 0.0;
|
|
angles.z = 0.0;
|
|
pEntity->SetAbsOrigin( GetAbsOrigin() );
|
|
pEntity->SetAbsAngles( angles );
|
|
|
|
IASW_Spawnable_NPC* pSpawnable = dynamic_cast<IASW_Spawnable_NPC*>(pEntity);
|
|
Assert( pSpawnable );
|
|
if ( !pSpawnable )
|
|
{
|
|
Warning( "NULL Spawnable Ent in asw_spawner! AlienClass = %s\n", szAlienClassName );
|
|
UTIL_Remove( pEntity );
|
|
return NULL;
|
|
}
|
|
m_flLastSpawnTime = gpGlobals->curtime;
|
|
if ( m_bStartBurrowed )
|
|
{
|
|
pSpawnable->StartBurrowed();
|
|
}
|
|
|
|
if ( m_bStartBurrowed )
|
|
{
|
|
pSpawnable->SetUnburrowIdleActivity( m_UnburrowIdleActivity );
|
|
pSpawnable->SetUnburrowActivity( m_UnburrowActivity );
|
|
}
|
|
|
|
DispatchSpawn( pEntity );
|
|
|
|
pEntity->SetOwnerEntity( this );
|
|
pEntity->Activate();
|
|
|
|
if ( m_AlienName != NULL_STRING )
|
|
{
|
|
pEntity->SetName( m_AlienName );
|
|
}
|
|
|
|
pSpawnable->SetSpawner( this );
|
|
|
|
RemoveObstructingProps( pEntity );
|
|
|
|
// give our aliens the orders
|
|
pSpawnable->SetAlienOrders( m_AlienOrders, vec3_origin, GetOrderTarget() );
|
|
|
|
m_OnSpawned.FireOutput(pEntity, this);
|
|
|
|
return pSpawnable;
|
|
}
|
|
|
|
CBaseEntity* CASW_Base_Spawner::GetAlienOrderTarget()
|
|
{
|
|
return m_hAlienOrderTarget.Get();
|
|
}
|
|
|
|
bool CASW_Base_Spawner::IsValidOnThisSkillLevel()
|
|
{
|
|
if (m_iMinSkillLevel > 0 && ASWGameRules()->GetSkillLevel() < m_iMinSkillLevel)
|
|
return false;
|
|
if (m_iMaxSkillLevel > 0 && m_iMaxSkillLevel < 10
|
|
&& ASWGameRules()->GetSkillLevel() > m_iMaxSkillLevel)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CASW_Base_Spawner::HasRecentlySpawned( float flRecent )
|
|
{
|
|
return m_flLastSpawnTime > 0.0f && ( ( gpGlobals->curtime - m_flLastSpawnTime ) < flRecent );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Inputs
|
|
//------------------------------------------------------------------------------
|
|
void CASW_Base_Spawner::InputToggleEnabled( inputdata_t &inputdata )
|
|
{
|
|
if ( !m_bEnabled )
|
|
{
|
|
InputEnable( inputdata );
|
|
}
|
|
else
|
|
{
|
|
InputDisable( inputdata );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CASW_Base_Spawner::InputEnable( inputdata_t &inputdata )
|
|
{
|
|
if ( !m_bEnabled )
|
|
{
|
|
m_bEnabled = true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CASW_Base_Spawner::InputDisable( inputdata_t &inputdata )
|
|
{
|
|
if ( m_bEnabled )
|
|
{
|
|
m_bEnabled = false;
|
|
}
|
|
} |