mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-29 17:43:01 +00:00
657 lines
21 KiB
C++
657 lines
21 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "item_dynamic_resupply.h"
|
|
#include "props.h"
|
|
#include "items.h"
|
|
#include "ammodef.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
ConVar sk_dynamic_resupply_modifier( "sk_dynamic_resupply_modifier","1.0" );
|
|
extern ConVar sk_battery;
|
|
extern ConVar sk_healthkit;
|
|
|
|
ConVar g_debug_dynamicresupplies( "g_debug_dynamicresupplies", "0", FCVAR_NONE, "Debug item_dynamic_resupply spawning. Set to 1 to see text printouts of the spawning. Set to 2 to see lines drawn to other items factored into the spawning." );
|
|
|
|
struct DynamicResupplyItems_t
|
|
{
|
|
const char *sEntityName;
|
|
const char *sAmmoDef;
|
|
int iAmmoCount;
|
|
float flFullProbability; // Probability of spawning if the player meeds all goals
|
|
};
|
|
|
|
struct SpawnInfo_t
|
|
{
|
|
float m_flDesiredRatio;
|
|
float m_flCurrentRatio;
|
|
float m_flDelta;
|
|
int m_iPotentialItems;
|
|
};
|
|
|
|
|
|
// Health types
|
|
static DynamicResupplyItems_t g_DynamicResupplyHealthItems[] =
|
|
{
|
|
{ "item_healthkit", "Health", 0, 0.0f, },
|
|
{ "item_battery", "Armor", 0, 0.0f },
|
|
};
|
|
|
|
// Ammo types
|
|
static DynamicResupplyItems_t g_DynamicResupplyAmmoItems[] =
|
|
{
|
|
{ "item_ammo_pistol", "Pistol", SIZE_AMMO_PISTOL, 0.5f },
|
|
{ "item_ammo_smg1", "SMG1", SIZE_AMMO_SMG1, 0.4f },
|
|
{ "item_ammo_smg1_grenade", "SMG1_Grenade", SIZE_AMMO_SMG1_GRENADE, 0.0f },
|
|
{ "item_ammo_ar2", "AR2", SIZE_AMMO_AR2, 0.0f },
|
|
{ "item_box_buckshot", "Buckshot", SIZE_AMMO_BUCKSHOT, 0.0f },
|
|
{ "item_rpg_round", "RPG_Round", SIZE_AMMO_RPG_ROUND, 0.0f },
|
|
{ "weapon_frag", "Grenade", 1, 0.1f },
|
|
{ "item_ammo_357", "357", SIZE_AMMO_357, 0.0f },
|
|
{ "item_ammo_crossbow", "XBowBolt", SIZE_AMMO_CROSSBOW, 0.0f },
|
|
{ "item_ammo_ar2_altfire", "AR2AltFire", SIZE_AMMO_AR2_ALTFIRE, 0.0f },
|
|
};
|
|
|
|
#define DS_HEALTH_INDEX 0
|
|
#define DS_ARMOR_INDEX 1
|
|
#define DS_GRENADE_INDEX 6
|
|
|
|
#define NUM_HEALTH_ITEMS (ARRAYSIZE(g_DynamicResupplyHealthItems))
|
|
#define NUM_AMMO_ITEMS (ARRAYSIZE(g_DynamicResupplyAmmoItems))
|
|
|
|
#define DYNAMIC_ITEM_THINK 1.0
|
|
|
|
#define POTENTIAL_ITEM_RADIUS 1024
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: An item that dynamically decides what the player needs most and spawns that.
|
|
//-----------------------------------------------------------------------------
|
|
class CItem_DynamicResupply : public CPointEntity
|
|
{
|
|
DECLARE_CLASS( CItem_DynamicResupply, CPointEntity );
|
|
public:
|
|
DECLARE_DATADESC();
|
|
|
|
CItem_DynamicResupply();
|
|
|
|
void Spawn( void );
|
|
void Precache( void );
|
|
void Activate( void );
|
|
void CheckPVSThink( void );
|
|
|
|
// Inputs
|
|
void InputKill( inputdata_t &data );
|
|
void InputCalculateType( inputdata_t &data );
|
|
void InputBecomeMaster( inputdata_t &data );
|
|
|
|
float GetDesiredHealthPercentage( void ) const { return m_flDesiredHealth[0]; }
|
|
|
|
private:
|
|
friend void DynamicResupply_InitFromAlternateMaster( CBaseEntity *pTargetEnt, string_t iszMaster );
|
|
void FindPotentialItems( int nCount, DynamicResupplyItems_t *pItems, int iDebug, SpawnInfo_t *pSpawnInfo );
|
|
void ComputeHealthRatios( CItem_DynamicResupply* pMaster, CBasePlayer *pPlayer, int iDebug, SpawnInfo_t *pSpawnInfo );
|
|
void ComputeAmmoRatios( CItem_DynamicResupply* pMaster, CBasePlayer *pPlayer, int iDebug, SpawnInfo_t *pSpawnInfo );
|
|
bool SpawnItemFromRatio( int nCount, DynamicResupplyItems_t *pItems, int iDebug, SpawnInfo_t *pSpawnInfo, Vector *pVecSpawnOrigin );
|
|
|
|
// Spawns an item when the player is full
|
|
void SpawnFullItem( CItem_DynamicResupply *pMaster, CBasePlayer *pPlayer, int iDebug );
|
|
void SpawnDynamicItem( CBasePlayer *pPlayer );
|
|
|
|
enum Versions
|
|
{
|
|
VERSION_0,
|
|
VERSION_1_PERSISTENT_MASTER,
|
|
|
|
VERSION_CURRENT = VERSION_1_PERSISTENT_MASTER,
|
|
};
|
|
|
|
int m_version;
|
|
float m_flDesiredHealth[ NUM_HEALTH_ITEMS ];
|
|
float m_flDesiredAmmo[ NUM_AMMO_ITEMS ];
|
|
|
|
bool m_bIsMaster;
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS(item_dynamic_resupply, CItem_DynamicResupply);
|
|
|
|
// Master
|
|
typedef CHandle<CItem_DynamicResupply> DynamicResupplyHandle_t;
|
|
|
|
static DynamicResupplyHandle_t g_MasterResupply;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Save/load:
|
|
//-----------------------------------------------------------------------------
|
|
BEGIN_DATADESC( CItem_DynamicResupply )
|
|
|
|
DEFINE_THINKFUNC( CheckPVSThink ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "Kill", InputKill ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "CalculateType", InputCalculateType ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "BecomeMaster", InputBecomeMaster ),
|
|
|
|
DEFINE_KEYFIELD( m_flDesiredHealth[0], FIELD_FLOAT, "DesiredHealth" ),
|
|
DEFINE_KEYFIELD( m_flDesiredHealth[1], FIELD_FLOAT, "DesiredArmor" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[0], FIELD_FLOAT, "DesiredAmmoPistol" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[1], FIELD_FLOAT, "DesiredAmmoSMG1" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[2], FIELD_FLOAT, "DesiredAmmoSMG1_Grenade" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[3], FIELD_FLOAT, "DesiredAmmoAR2" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[4], FIELD_FLOAT, "DesiredAmmoBuckshot" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[5], FIELD_FLOAT, "DesiredAmmoRPG_Round" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[6], FIELD_FLOAT, "DesiredAmmoGrenade" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[7], FIELD_FLOAT, "DesiredAmmo357" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[8], FIELD_FLOAT, "DesiredAmmoCrossbow" ),
|
|
DEFINE_KEYFIELD( m_flDesiredAmmo[9], FIELD_FLOAT, "DesiredAmmoAR2_AltFire" ),
|
|
|
|
DEFINE_FIELD( m_version, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_bIsMaster, FIELD_BOOLEAN ),
|
|
|
|
// Silence, Classcheck!
|
|
// DEFINE_ARRAY( m_flDesiredHealth, FIELD_FLOAT, NUM_HEALTH_ITEMS ),
|
|
// DEFINE_ARRAY( m_flDesiredAmmo, FIELD_FLOAT, NUM_AMMO_ITEMS ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CItem_DynamicResupply::CItem_DynamicResupply( void )
|
|
{
|
|
AddSpawnFlags( SF_DYNAMICRESUPPLY_USE_MASTER );
|
|
m_version = VERSION_CURRENT;
|
|
|
|
// Setup default values
|
|
m_flDesiredHealth[0] = 1.0; // Health
|
|
m_flDesiredHealth[1] = 0.3; // Armor
|
|
m_flDesiredAmmo[0] = 0.5; // Pistol
|
|
m_flDesiredAmmo[1] = 0.5; // SMG1
|
|
m_flDesiredAmmo[2] = 0.1; // SMG1 Grenade
|
|
m_flDesiredAmmo[3] = 0.4; // AR2
|
|
m_flDesiredAmmo[4] = 0.5; // Shotgun
|
|
m_flDesiredAmmo[5] = 0.0; // RPG Round
|
|
m_flDesiredAmmo[6] = 0.1; // Grenade
|
|
m_flDesiredAmmo[7] = 0; // 357
|
|
m_flDesiredAmmo[8] = 0; // Crossbow
|
|
m_flDesiredAmmo[9] = 0; // AR2 alt-fire
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::Spawn( void )
|
|
{
|
|
if ( g_pGameRules->IsAllowedToSpawn( this ) == false )
|
|
{
|
|
UTIL_Remove( this );
|
|
return;
|
|
}
|
|
|
|
// Don't callback to spawn
|
|
Precache();
|
|
|
|
m_bIsMaster = HasSpawnFlags( SF_DYNAMICRESUPPLY_IS_MASTER );
|
|
|
|
// Am I the master?
|
|
if ( !HasSpawnFlags( SF_DYNAMICRESUPPLY_IS_MASTER | SF_DYNAMICRESUPPLY_ALTERNATE_MASTER ) )
|
|
{
|
|
// Stagger the thinks a bit so they don't all think at the same time
|
|
SetNextThink( gpGlobals->curtime + RandomFloat(0.2f, 0.4f) );
|
|
SetThink( &CItem_DynamicResupply::CheckPVSThink );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::Activate( void )
|
|
{
|
|
BaseClass::Activate();
|
|
|
|
if ( HasSpawnFlags( SF_DYNAMICRESUPPLY_IS_MASTER ) )
|
|
{
|
|
if ( !g_MasterResupply && ( m_bIsMaster || m_version < VERSION_1_PERSISTENT_MASTER ) )
|
|
{
|
|
g_MasterResupply = this;
|
|
}
|
|
else
|
|
{
|
|
m_bIsMaster = false;
|
|
}
|
|
}
|
|
if ( !HasSpawnFlags( SF_DYNAMICRESUPPLY_ALTERNATE_MASTER ) && HasSpawnFlags( SF_DYNAMICRESUPPLY_USE_MASTER ) && gpGlobals->curtime < 1.0 )
|
|
{
|
|
if ( !g_MasterResupply )
|
|
{
|
|
Warning( "item_dynamic_resupply set to 'Use Master', but no item_dynamic_resupply master exists.\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::Precache( void )
|
|
{
|
|
// Precache all the items potentially spawned
|
|
int i;
|
|
for ( i = 0; i < NUM_HEALTH_ITEMS; i++ )
|
|
{
|
|
UTIL_PrecacheOther( g_DynamicResupplyHealthItems[i].sEntityName );
|
|
}
|
|
|
|
for ( i = 0; i < NUM_AMMO_ITEMS; i++ )
|
|
{
|
|
UTIL_PrecacheOther( g_DynamicResupplyAmmoItems[i].sEntityName );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::CheckPVSThink( void )
|
|
{
|
|
edict_t *pentPlayer = UTIL_FindClientInPVS( edict() );
|
|
if ( pentPlayer )
|
|
{
|
|
CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance( pentPlayer );
|
|
if ( pPlayer )
|
|
{
|
|
SpawnDynamicItem( pPlayer );
|
|
return;
|
|
}
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + DYNAMIC_ITEM_THINK );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &data -
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::InputKill( inputdata_t &data )
|
|
{
|
|
UTIL_Remove( this );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &data -
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::InputCalculateType( inputdata_t &data )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
SpawnDynamicItem( pPlayer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &data -
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::InputBecomeMaster( inputdata_t &data )
|
|
{
|
|
if ( g_MasterResupply )
|
|
g_MasterResupply->m_bIsMaster = false;
|
|
|
|
g_MasterResupply = this;
|
|
m_bIsMaster = true;
|
|
|
|
// Stop thinking now that I am the master.
|
|
SetThink( NULL );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Chooses an item when the player is full
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::SpawnFullItem( CItem_DynamicResupply *pMaster, CBasePlayer *pPlayer, int iDebug )
|
|
{
|
|
// Can we not actually spawn the item?
|
|
if ( !HasSpawnFlags(SF_DYNAMICRESUPPLY_ALWAYS_SPAWN) )
|
|
return;
|
|
|
|
float flRatio[NUM_AMMO_ITEMS];
|
|
int i;
|
|
float flTotalProb = 0.0f;
|
|
for ( i = 0; i < NUM_AMMO_ITEMS; ++i )
|
|
{
|
|
int iAmmoType = GetAmmoDef()->Index( g_DynamicResupplyAmmoItems[i].sAmmoDef );
|
|
bool bCanSpawn = pPlayer->Weapon_GetWpnForAmmo( iAmmoType ) != NULL;
|
|
|
|
if ( bCanSpawn && ( g_DynamicResupplyAmmoItems[i].flFullProbability != 0 ) && ( pMaster->m_flDesiredAmmo[i] != 0.0f ) )
|
|
{
|
|
flTotalProb += g_DynamicResupplyAmmoItems[i].flFullProbability;
|
|
flRatio[i] = flTotalProb;
|
|
}
|
|
else
|
|
{
|
|
flRatio[i] = -1.0f;
|
|
}
|
|
}
|
|
|
|
if ( flTotalProb == 0.0f )
|
|
{
|
|
// If we're supposed to fallback to just a health vial, do that and finish.
|
|
if ( pMaster->HasSpawnFlags(SF_DYNAMICRESUPPLY_FALLBACK_TO_VIAL) )
|
|
{
|
|
CBaseEntity::Create( "item_healthvial", GetAbsOrigin(), GetAbsAngles(), this );
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Player is full, spawning item_healthvial due to spawnflag.\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Otherwise, spawn the first ammo item in the list
|
|
flRatio[0] = 1.0f;
|
|
flTotalProb = 1.0f;
|
|
}
|
|
|
|
float flChoice = random->RandomFloat( 0.0f, flTotalProb );
|
|
for ( i = 0; i < NUM_AMMO_ITEMS; ++i )
|
|
{
|
|
if ( flChoice <= flRatio[i] )
|
|
{
|
|
CBaseEntity::Create( g_DynamicResupplyAmmoItems[i].sEntityName, GetAbsOrigin(), GetAbsAngles(), this );
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Player is full, spawning %s \n", g_DynamicResupplyAmmoItems[i].sEntityName );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Player is full on all health + ammo, is not spawning.\n" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::FindPotentialItems( int nCount, DynamicResupplyItems_t *pItems, int iDebug, SpawnInfo_t *pSpawnInfo )
|
|
{
|
|
int i;
|
|
for ( i = 0; i < nCount; ++i )
|
|
{
|
|
pSpawnInfo[i].m_iPotentialItems = 0;
|
|
}
|
|
|
|
// Count the potential addition of items in the PVS
|
|
CBaseEntity *pEntity = NULL;
|
|
while ( (pEntity = UTIL_EntitiesInPVS( this, pEntity )) != NULL )
|
|
{
|
|
if ( pEntity->WorldSpaceCenter().DistToSqr( WorldSpaceCenter() ) > (POTENTIAL_ITEM_RADIUS * POTENTIAL_ITEM_RADIUS) )
|
|
continue;
|
|
|
|
for ( i = 0; i < nCount; ++i )
|
|
{
|
|
if ( !FClassnameIs( pEntity, pItems[i].sEntityName ) )
|
|
continue;
|
|
|
|
if ( iDebug == 2 )
|
|
{
|
|
NDebugOverlay::Line( WorldSpaceCenter(), pEntity->WorldSpaceCenter(), 0,255,0, true, 20.0 );
|
|
}
|
|
|
|
++pSpawnInfo[i].m_iPotentialItems;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Searching the PVS:\n");
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
Msg(" Found %d '%s' in the PVS.\n", pSpawnInfo[i].m_iPotentialItems, pItems[i].sEntityName );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::ComputeHealthRatios( CItem_DynamicResupply* pMaster, CBasePlayer *pPlayer, int iDebug, SpawnInfo_t *pSpawnInfo )
|
|
{
|
|
for ( int i = 0; i < NUM_HEALTH_ITEMS; i++ )
|
|
{
|
|
// Figure out the current level of this resupply type
|
|
float flMax;
|
|
if ( i == DS_HEALTH_INDEX )
|
|
{
|
|
// Health
|
|
flMax = pPlayer->GetMaxHealth();
|
|
|
|
float flCurrentHealth = pPlayer->GetHealth() + (pSpawnInfo[i].m_iPotentialItems * sk_healthkit.GetFloat());
|
|
pSpawnInfo[i].m_flCurrentRatio = (flCurrentHealth / flMax);
|
|
}
|
|
else if ( i == DS_ARMOR_INDEX )
|
|
{
|
|
// Armor
|
|
// Ignore armor if we don't have the suit
|
|
if ( !pPlayer->IsSuitEquipped() )
|
|
{
|
|
pSpawnInfo[i].m_flCurrentRatio = 1.0;
|
|
}
|
|
else
|
|
{
|
|
flMax = MAX_NORMAL_BATTERY;
|
|
float flCurrentArmor = pPlayer->ArmorValue() + (pSpawnInfo[i].m_iPotentialItems * sk_battery.GetFloat());
|
|
pSpawnInfo[i].m_flCurrentRatio = (flCurrentArmor / flMax);
|
|
}
|
|
}
|
|
|
|
pSpawnInfo[i].m_flDesiredRatio = pMaster->m_flDesiredHealth[i] * sk_dynamic_resupply_modifier.GetFloat();
|
|
pSpawnInfo[i].m_flDelta = pSpawnInfo[i].m_flDesiredRatio - pSpawnInfo[i].m_flCurrentRatio;
|
|
pSpawnInfo[i].m_flDelta = clamp( pSpawnInfo[i].m_flDelta, 0, 1 );
|
|
}
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Calculating desired health ratios & deltas:\n");
|
|
for ( int i = 0; i < NUM_HEALTH_ITEMS; i++ )
|
|
{
|
|
Msg(" %s Desired Ratio: %.2f, Current Ratio: %.2f = Delta of %.2f\n",
|
|
g_DynamicResupplyHealthItems[i].sEntityName, pSpawnInfo[i].m_flDesiredRatio, pSpawnInfo[i].m_flCurrentRatio, pSpawnInfo[i].m_flDelta );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::ComputeAmmoRatios( CItem_DynamicResupply* pMaster, CBasePlayer *pPlayer, int iDebug, SpawnInfo_t *pSpawnInfo )
|
|
{
|
|
for ( int i = 0; i < NUM_AMMO_ITEMS; i++ )
|
|
{
|
|
// Get the ammodef's
|
|
int iAmmoType = GetAmmoDef()->Index( g_DynamicResupplyAmmoItems[i].sAmmoDef );
|
|
Assert( iAmmoType != -1 );
|
|
|
|
// Ignore ammo types if we don't have a weapon that uses it (except for the grenade)
|
|
if ( (i != DS_GRENADE_INDEX) && !pPlayer->Weapon_GetWpnForAmmo( iAmmoType ) )
|
|
{
|
|
pSpawnInfo[i].m_flCurrentRatio = 1.0;
|
|
}
|
|
else
|
|
{
|
|
float flMax = GetAmmoDef()->MaxCarry( iAmmoType );
|
|
float flCurrentAmmo = pPlayer->GetAmmoCount( iAmmoType );
|
|
flCurrentAmmo += (pSpawnInfo[i].m_iPotentialItems * g_DynamicResupplyAmmoItems[i].iAmmoCount);
|
|
pSpawnInfo[i].m_flCurrentRatio = (flCurrentAmmo / flMax);
|
|
}
|
|
|
|
// Use the master if we're supposed to
|
|
pSpawnInfo[i].m_flDesiredRatio = pMaster->m_flDesiredAmmo[i] * sk_dynamic_resupply_modifier.GetFloat();
|
|
pSpawnInfo[i].m_flDelta = pSpawnInfo[i].m_flDesiredRatio - pSpawnInfo[i].m_flCurrentRatio;
|
|
pSpawnInfo[i].m_flDelta = clamp( pSpawnInfo[i].m_flDelta, 0, 1 );
|
|
}
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Calculating desired ammo ratios & deltas:\n");
|
|
for ( int i = 0; i < NUM_AMMO_ITEMS; i++ )
|
|
{
|
|
Msg(" %s Desired Ratio: %.2f, Current Ratio: %.2f = Delta of %.2f\n",
|
|
g_DynamicResupplyAmmoItems[i].sEntityName, pSpawnInfo[i].m_flDesiredRatio, pSpawnInfo[i].m_flCurrentRatio, pSpawnInfo[i].m_flDelta );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CItem_DynamicResupply::SpawnItemFromRatio( int nCount, DynamicResupplyItems_t *pItems, int iDebug, SpawnInfo_t *pSpawnInfo, Vector *pVecSpawnOrigin )
|
|
{
|
|
// Now find the one we're farthest from
|
|
float flFarthest = 0;
|
|
int iSelectedIndex = -1;
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( pSpawnInfo[i].m_flDelta > flFarthest )
|
|
{
|
|
flFarthest = pSpawnInfo[i].m_flDelta;
|
|
iSelectedIndex = i;
|
|
}
|
|
}
|
|
|
|
if ( iSelectedIndex < 0 )
|
|
return false;
|
|
|
|
if ( iDebug )
|
|
{
|
|
Msg("Chosen item: %s (had farthest delta, %.2f)\n", pItems[iSelectedIndex].sEntityName, pSpawnInfo[iSelectedIndex].m_flDelta );
|
|
}
|
|
|
|
CBaseEntity *pEnt = CBaseEntity::Create( pItems[iSelectedIndex].sEntityName, *pVecSpawnOrigin, GetAbsAngles(), this );
|
|
pEnt->SetAbsVelocity( GetAbsVelocity() );
|
|
pEnt->SetLocalAngularVelocity( GetLocalAngularVelocity() );
|
|
|
|
// Move the entity up so that it doesn't go below the spawn origin
|
|
Vector vecWorldMins, vecWorldMaxs;
|
|
pEnt->CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs );
|
|
if ( vecWorldMins.z < pVecSpawnOrigin->z )
|
|
{
|
|
float dz = pVecSpawnOrigin->z - vecWorldMins.z;
|
|
pVecSpawnOrigin->z += dz;
|
|
vecWorldMaxs.z += dz;
|
|
pEnt->SetAbsOrigin( *pVecSpawnOrigin );
|
|
}
|
|
|
|
// Update the spawn position to spawn them on top of each other
|
|
pVecSpawnOrigin->z = vecWorldMaxs.z + 6.0f;
|
|
|
|
pVecSpawnOrigin->x += random->RandomFloat( -6, 6 );
|
|
pVecSpawnOrigin->y += random->RandomFloat( -6, 6 );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CItem_DynamicResupply::SpawnDynamicItem( CBasePlayer *pPlayer )
|
|
{
|
|
Assert( pPlayer );
|
|
|
|
// If we're the master, we never want to spawn
|
|
if ( g_MasterResupply == this )
|
|
return;
|
|
|
|
int iDebug = g_debug_dynamicresupplies.GetInt();
|
|
if ( iDebug )
|
|
{
|
|
Msg("Spawning item_dynamic_resupply:\n");
|
|
}
|
|
|
|
SpawnInfo_t pAmmoInfo[ NUM_AMMO_ITEMS ];
|
|
SpawnInfo_t pHealthInfo[ NUM_HEALTH_ITEMS ];
|
|
|
|
// Count the potential addition of items in the PVS
|
|
FindPotentialItems( NUM_HEALTH_ITEMS, g_DynamicResupplyHealthItems, iDebug, pHealthInfo );
|
|
FindPotentialItems( NUM_AMMO_ITEMS, g_DynamicResupplyAmmoItems, iDebug, pAmmoInfo );
|
|
|
|
// Use the master if we're supposed to
|
|
CItem_DynamicResupply *pMaster = this;
|
|
if ( HasSpawnFlags( SF_DYNAMICRESUPPLY_USE_MASTER ) && g_MasterResupply )
|
|
{
|
|
pMaster = g_MasterResupply;
|
|
}
|
|
|
|
// Compute desired ratios for health and ammo
|
|
ComputeHealthRatios( pMaster, pPlayer, iDebug, pHealthInfo );
|
|
ComputeAmmoRatios( pMaster, pPlayer, iDebug, pAmmoInfo );
|
|
|
|
Vector vecSpawnOrigin = GetAbsOrigin();
|
|
bool bHealthSpawned = SpawnItemFromRatio( NUM_HEALTH_ITEMS, g_DynamicResupplyHealthItems, iDebug, pHealthInfo, &vecSpawnOrigin );
|
|
bool bAmmoSpawned = SpawnItemFromRatio( NUM_AMMO_ITEMS, g_DynamicResupplyAmmoItems, iDebug, pAmmoInfo, &vecSpawnOrigin );
|
|
if ( !bHealthSpawned && !bAmmoSpawned )
|
|
{
|
|
SpawnFullItem( pMaster, pPlayer, iDebug );
|
|
}
|
|
|
|
SetThink( NULL );
|
|
UTIL_Remove( this );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float DynamicResupply_GetDesiredHealthPercentage( void )
|
|
{
|
|
// Return what the master supply dictates
|
|
if ( g_MasterResupply != NULL )
|
|
return g_MasterResupply->GetDesiredHealthPercentage();
|
|
|
|
// Full health if they haven't specified otherwise
|
|
return 1.0f;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void DynamicResupply_InitFromAlternateMaster( CBaseEntity *pTargetEnt, string_t iszMaster )
|
|
{
|
|
if ( iszMaster== NULL_STRING )
|
|
{
|
|
return;
|
|
}
|
|
|
|
CItem_DynamicResupply *pTargetResupply = assert_cast<CItem_DynamicResupply *>( pTargetEnt );
|
|
CBaseEntity *pMasterEnt = gEntList.FindEntityByName( NULL, iszMaster );
|
|
|
|
if ( !pMasterEnt || !pMasterEnt->ClassMatches( pTargetResupply->GetClassname() ) )
|
|
{
|
|
DevWarning( "Invalid item_dynamic_resupply name %s\n", STRING( iszMaster ) );
|
|
return;
|
|
}
|
|
|
|
CItem_DynamicResupply *pMasterResupply = assert_cast<CItem_DynamicResupply *>( pMasterEnt );
|
|
|
|
pTargetResupply->RemoveSpawnFlags( SF_DYNAMICRESUPPLY_USE_MASTER );
|
|
memcpy( pTargetResupply->m_flDesiredHealth, pMasterResupply->m_flDesiredHealth, sizeof( pMasterResupply->m_flDesiredHealth ) );
|
|
memcpy( pTargetResupply->m_flDesiredAmmo, pMasterResupply->m_flDesiredAmmo, sizeof( pMasterResupply->m_flDesiredAmmo ) );
|
|
|
|
} |