Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.

1285 lines
32 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "soundenvelope.h"
#include "Sprite.h"
#include "entitylist.h"
#include "ai_basenpc.h"
#include "soundent.h"
#include "explode.h"
#include "physics.h"
#include "physics_saverestore.h"
#include "combine_mine.h"
#include "movevars_shared.h"
#include "vphysics/constraints.h"
#include "ai_hint.h"
enum
{
MINE_STATE_DORMANT = 0,
MINE_STATE_DEPLOY, // Try to lock down and arm
MINE_STATE_CAPTIVE, // Held in the physgun
MINE_STATE_ARMED, // Locked down and looking for targets
MINE_STATE_TRIGGERED, // No turning back. I'm going to explode when I touch something.
MINE_STATE_LAUNCHED, // Similar. Thrown from physgun.
};
// for the Modification keyfield
enum
{
MINE_MODIFICATION_NORMAL = 0,
MINE_MODIFICATION_CAVERN,
};
// the citizen modified skins for the mine (inclusive):
#define MINE_CITIZEN_SKIN_MIN 1
#define MINE_CITIZEN_SKIN_MAX 2
char *pszMineStateNames[] =
{
"Dormant",
"Deploy",
"Captive",
"Armed",
"Triggered",
"Launched",
};
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// After this many flips, seriously cut the frequency with which you try.
#define BOUNCEBOMB_MAX_FLIPS 5
// Approximate radius of the bomb's model
#define BOUNCEBOMB_RADIUS 24
BEGIN_DATADESC( CBounceBomb )
DEFINE_THINKFUNC( ExplodeThink ),
DEFINE_ENTITYFUNC( ExplodeTouch ),
DEFINE_THINKFUNC( SearchThink ),
DEFINE_THINKFUNC( BounceThink ),
DEFINE_THINKFUNC( SettleThink ),
DEFINE_THINKFUNC( CaptiveThink ),
DEFINE_THINKFUNC( CavernBounceThink ),
DEFINE_SOUNDPATCH( m_pWarnSound ),
DEFINE_KEYFIELD( m_flExplosionDelay, FIELD_FLOAT, "ExplosionDelay" ),
DEFINE_KEYFIELD( m_bBounce, FIELD_BOOLEAN, "Bounce" ),
DEFINE_FIELD( m_bAwake, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hNearestNPC, FIELD_EHANDLE ),
DEFINE_FIELD( m_hSprite, FIELD_EHANDLE ),
DEFINE_FIELD( m_LastSpriteColor, FIELD_COLOR32 ),
DEFINE_FIELD( m_flHookPositions, FIELD_FLOAT ),
DEFINE_FIELD( m_iHookN, FIELD_INTEGER ),
DEFINE_FIELD( m_iHookE, FIELD_INTEGER ),
DEFINE_FIELD( m_iHookS, FIELD_INTEGER ),
DEFINE_FIELD( m_iAllHooks, FIELD_INTEGER ),
DEFINE_KEYFIELD( m_bLockSilently, FIELD_BOOLEAN, "LockSilently" ),
DEFINE_FIELD( m_bFoeNearest, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flIgnoreWorldTime, FIELD_TIME ),
DEFINE_KEYFIELD( m_bDisarmed, FIELD_BOOLEAN, "StartDisarmed" ),
DEFINE_KEYFIELD( m_iModification, FIELD_INTEGER, "Modification" ),
DEFINE_FIELD( m_bPlacedByPlayer, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bHeldByPhysgun, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iFlipAttempts, FIELD_INTEGER ),
DEFINE_FIELD( m_flTimeGrabbed, FIELD_TIME ),
DEFINE_FIELD( m_iMineState, FIELD_INTEGER ),
// Physics Influence
DEFINE_FIELD( m_hPhysicsAttacker, FIELD_EHANDLE ),
DEFINE_FIELD( m_flLastPhysicsInfluenceTime, FIELD_TIME ),
DEFINE_PHYSPTR( m_pConstraint ),
DEFINE_OUTPUT( m_OnPulledUp, "OnPulledUp" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disarm", InputDisarm ),
END_DATADESC()
string_t CBounceBomb::gm_iszFloorTurretClassname;
string_t CBounceBomb::gm_iszGroundTurretClassname;
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Precache()
{
PrecacheModel("models/props_combine/combine_mine01.mdl");
PrecacheScriptSound( "NPC_CombineMine.Hop" );
PrecacheScriptSound( "NPC_CombineMine.FlipOver" );
PrecacheScriptSound( "NPC_CombineMine.TurnOn" );
PrecacheScriptSound( "NPC_CombineMine.TurnOff" );
PrecacheScriptSound( "NPC_CombineMine.OpenHooks" );
PrecacheScriptSound( "NPC_CombineMine.CloseHooks" );
PrecacheScriptSound( "NPC_CombineMine.ActiveLoop" );
PrecacheModel( "sprites/glow01.vmt" );
gm_iszFloorTurretClassname = AllocPooledString( "npc_turret_floor" );
gm_iszGroundTurretClassname = AllocPooledString( "npc_turret_ground" );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Spawn()
{
Precache();
Wake( false );
SetModel("models/props_combine/combine_mine01.mdl");
SetSolid( SOLID_VPHYSICS );
m_hSprite.Set( NULL );
m_takedamage = DAMAGE_EVENTS_ONLY;
// Find my feet!
m_iHookN = LookupPoseParameter( "blendnorth" );
m_iHookE = LookupPoseParameter( "blendeast" );
m_iHookS = LookupPoseParameter( "blendsouth" );
m_iAllHooks = LookupPoseParameter( "blendstates" );
m_flHookPositions = 0;
SetHealth( 100 );
m_bBounce = true;
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
OpenHooks( true );
m_bHeldByPhysgun = false;
m_iFlipAttempts = 0;
if( !GetParent() )
{
// Create vphysics now if I'm not being carried.
CreateVPhysics();
}
m_flTimeGrabbed = FLT_MAX;
if( m_bDisarmed )
{
SetMineState( MINE_STATE_DORMANT );
}
else
{
SetMineState( MINE_STATE_DEPLOY );
}
// default to a different skin for cavern turrets (unless explicitly overridden)
if ( m_iModification == MINE_MODIFICATION_CAVERN )
{
// look for this value in the first datamap
// loop through the data description list, restoring each data desc block
datamap_t *dmap = GetDataDescMap();
bool bFoundSkin = false;
// search through all the readable fields in the data description, looking for a match
for ( int i = 0; i < dmap->dataNumFields; ++i )
{
if ( dmap->dataDesc[i].flags & (FTYPEDESC_OUTPUT | FTYPEDESC_KEY) )
{
if ( !Q_stricmp(dmap->dataDesc[i].externalName, "Skin") )
{
bFoundSkin = true;
break;
}
}
}
if (!bFoundSkin)
{
// select a random skin for the mine. Actually, we'll cycle through the available skins
// using a static variable to provide better distribution. The static isn't saved but
// really it's only cosmetic.
static unsigned int nextSkin = MINE_CITIZEN_SKIN_MIN;
m_nSkin = nextSkin;
// increment the skin for next time
nextSkin = (nextSkin >= MINE_CITIZEN_SKIN_MAX) ? MINE_CITIZEN_SKIN_MIN : nextSkin + 1;
}
// pretend like the player set me down.
m_bPlacedByPlayer = true;
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::OnRestore()
{
BaseClass::OnRestore();
if ( gpGlobals->eLoadType == MapLoad_Transition && !m_hSprite && m_LastSpriteColor.GetRawColor() != 0 )
{
UpdateLight( true, m_LastSpriteColor.r(), m_LastSpriteColor.g(), m_LastSpriteColor.b(), m_LastSpriteColor.a() );
}
if( VPhysicsGetObject() )
{
VPhysicsGetObject()->Wake();
}
}
//---------------------------------------------------------
//---------------------------------------------------------
int CBounceBomb::DrawDebugTextOverlays(void)
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
Q_snprintf(tempstr,sizeof(tempstr), "%s", pszMineStateNames[m_iMineState] );
EntityText(text_offset,tempstr,0);
text_offset++;
}
return text_offset;
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::SetMineState( int iState )
{
m_iMineState = iState;
switch( iState )
{
case MINE_STATE_DORMANT:
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pWarnSound, 0.0, 0.1 );
UpdateLight( false, 0, 0, 0, 0 );
SetThink( NULL );
}
break;
case MINE_STATE_CAPTIVE:
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pWarnSound, 0.0, 0.2 );
// Unhook
unsigned int flags = VPhysicsGetObject()->GetCallbackFlags();
VPhysicsGetObject()->SetCallbackFlags( flags | CALLBACK_GLOBAL_TOUCH_STATIC );
OpenHooks();
physenv->DestroyConstraint( m_pConstraint );
m_pConstraint = NULL;
UpdateLight( true, 0, 0, 255, 190 );
SetThink( &CBounceBomb::CaptiveThink );
SetNextThink( gpGlobals->curtime + 0.1f );
SetTouch( NULL );
}
break;
case MINE_STATE_DEPLOY:
OpenHooks( true );
UpdateLight( true, 0, 0, 255, 190 );
SetThink( &CBounceBomb::SettleThink );
SetTouch( NULL );
SetNextThink( gpGlobals->curtime + 0.1f );
break;
case MINE_STATE_ARMED:
UpdateLight( false, 0, 0, 0, 0 );
SetThink( &CBounceBomb::SearchThink );
SetNextThink( gpGlobals->curtime + 0.1f );
break;
case MINE_STATE_TRIGGERED:
{
OpenHooks();
if( m_pConstraint )
{
physenv->DestroyConstraint( m_pConstraint );
m_pConstraint = NULL;
}
// Scare NPC's
CSoundEnt::InsertSound( SOUND_DANGER, GetAbsOrigin(), 300, 1.0f, this );
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangeVolume( m_pWarnSound, 0.0, 0.2 );
SetTouch( &CBounceBomb::ExplodeTouch );
unsigned int flags = VPhysicsGetObject()->GetCallbackFlags();
VPhysicsGetObject()->SetCallbackFlags( flags | CALLBACK_GLOBAL_TOUCH_STATIC );
Vector vecNudge;
vecNudge.x = random->RandomFloat( -1, 1 );
vecNudge.y = random->RandomFloat( -1, 1 );
vecNudge.z = 1.5;
vecNudge *= 350;
VPhysicsGetObject()->Wake();
VPhysicsGetObject()->ApplyForceCenter( vecNudge );
float x, y;
x = 10 + random->RandomFloat( 0, 20 );
y = 10 + random->RandomFloat( 0, 20 );
VPhysicsGetObject()->ApplyTorqueCenter( AngularImpulse( x, y, 0 ) );
// Since we just nudged the mine, ignore collisions with the world until
// the mine is in the air. We only want to explode if the player tries to
// run over the mine before it jumps up.
m_flIgnoreWorldTime = gpGlobals->curtime + 1.0;
UpdateLight( true, 255, 0, 0, 190 );
// use the correct bounce behavior
if (m_iModification == MINE_MODIFICATION_CAVERN)
{
SetThink ( &CBounceBomb::CavernBounceThink );
SetNextThink( gpGlobals->curtime + 0.15 );
}
else
{
SetThink( &CBounceBomb::BounceThink );
SetNextThink( gpGlobals->curtime + 0.5 );
}
}
break;
case MINE_STATE_LAUNCHED:
{
UpdateLight( true, 255, 0, 0, 190 );
SetThink( NULL );
SetNextThink( gpGlobals->curtime + 0.5 );
SetTouch( &CBounceBomb::ExplodeTouch );
unsigned int flags = VPhysicsGetObject()->GetCallbackFlags();
VPhysicsGetObject()->SetCallbackFlags( flags | CALLBACK_GLOBAL_TOUCH_STATIC );
}
break;
default:
DevMsg("**Unknown Mine State: %d\n", iState );
break;
}
}
//---------------------------------------------------------
// Bouncbomb flips to try to right itself, try to get off
// of and object that it's not allowed to clamp to, or
// to get away from a hint node that inhibits placement
// of mines.
//---------------------------------------------------------
void CBounceBomb::Flip( const Vector &vecForce, const AngularImpulse &torque )
{
if( m_iFlipAttempts > BOUNCEBOMB_MAX_FLIPS )
{
// Not allowed to try anymore.
SetThink(NULL);
return;
}
EmitSound( "NPC_CombineMine.FlipOver" );
VPhysicsGetObject()->ApplyForceCenter( vecForce );
VPhysicsGetObject()->ApplyTorqueCenter( torque );
m_iFlipAttempts++;
}
//---------------------------------------------------------
//---------------------------------------------------------
#define MINE_MIN_PROXIMITY_SQR 676 // 27 inches
bool CBounceBomb::IsValidLocation()
{
CBaseEntity *pAvoidObject = NULL;
float flAvoidForce = 0.0f;
CAI_Hint *pHint;
CHintCriteria criteria;
criteria.SetHintType( HINT_WORLD_INHIBIT_COMBINE_MINES );
criteria.SetFlag( bits_HINT_NODE_NEAREST );
criteria.AddIncludePosition( GetAbsOrigin(), 12.0f * 15.0f );
pHint = CAI_HintManager::FindHint( GetAbsOrigin(), criteria );
if( pHint )
{
pAvoidObject = pHint;
flAvoidForce = 120.0f;
}
else
{
// Look for other mines that are too close to me.
CBaseEntity *pEntity = gEntList.FirstEnt();
Vector vecMyPosition = GetAbsOrigin();
while( pEntity )
{
if( pEntity->m_iClassname == m_iClassname && pEntity != this )
{
// Don't lock down if I'm near a mine that's already locked down.
if( vecMyPosition.DistToSqr(pEntity->GetAbsOrigin()) < MINE_MIN_PROXIMITY_SQR )
{
pAvoidObject = pEntity;
flAvoidForce = 60.0f;
break;
}
}
pEntity = gEntList.NextEnt( pEntity );
}
}
if( pAvoidObject )
{
// Build a force vector to push us away from the inhibitor.
// Start by pushing upwards.
Vector vecForce = Vector( 0, 0, VPhysicsGetObject()->GetMass() * 200.0f );
// Now add some force in the direction that takes us away from the inhibitor.
Vector vecDir = GetAbsOrigin() - pAvoidObject->GetAbsOrigin();
vecDir.z = 0.0f;
VectorNormalize( vecDir );
vecForce += vecDir * VPhysicsGetObject()->GetMass() * flAvoidForce;
Flip( vecForce, AngularImpulse( 100, 0, 0 ) );
// Tell the code that asked that this position isn't valid.
return false;
}
return true;
}
//---------------------------------------------------------
// Release the spikes
//---------------------------------------------------------
void CBounceBomb::BounceThink()
{
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance();
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject != NULL )
{
const float MINE_MAX_JUMP_HEIGHT = 200;
// Figure out how much headroom the mine has, and hop to within a few inches of that.
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, MINE_MAX_JUMP_HEIGHT ), MASK_SHOT, this, COLLISION_GROUP_INTERACTIVE, &tr );
float height;
if( tr.m_pEnt && tr.m_pEnt->VPhysicsGetObject() )
{
// Physics object resting on me. Jump as hard as allowed to try to knock it away.
height = MINE_MAX_JUMP_HEIGHT;
}
else
{
height = tr.endpos.z - GetAbsOrigin().z;
height -= BOUNCEBOMB_RADIUS;
if ( height < 0.1 )
height = 0.1;
}
float time = sqrt( height / (0.5 * GetCurrentGravity()) );
float velocity = GetCurrentGravity() * time;
// or you can just AddVelocity to the object instead of ApplyForce
float force = velocity * pPhysicsObject->GetMass();
Vector up;
GetVectors( NULL, NULL, &up );
pPhysicsObject->Wake();
pPhysicsObject->ApplyForceCenter( up * force );
pPhysicsObject->ApplyTorqueCenter( AngularImpulse( random->RandomFloat( 5, 25 ), random->RandomFloat( 5, 25 ), 0 ) );
if( m_hNearestNPC )
{
Vector vecPredict = m_hNearestNPC->GetSmoothedVelocity();
pPhysicsObject->ApplyForceCenter( vecPredict * 10 );
}
EmitSound( "NPC_CombineMine.Hop" );
SetThink( NULL );
}
}
//---------------------------------------------------------
// A different bounce behavior for the citizen-modified mine. Detonates at the top of its apex,
// and does not attempt to track enemies.
//---------------------------------------------------------
void CBounceBomb::CavernBounceThink()
{
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance();
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject != NULL )
{
const float MINE_MAX_JUMP_HEIGHT = 78;
// Figure out how much headroom the mine has, and hop to within a few inches of that.
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, MINE_MAX_JUMP_HEIGHT ), MASK_SHOT, this, COLLISION_GROUP_INTERACTIVE, &tr );
float height;
if( tr.m_pEnt && tr.m_pEnt->VPhysicsGetObject() )
{
// Physics object resting on me. Jump as hard as allowed to try to knock it away.
height = MINE_MAX_JUMP_HEIGHT;
}
else
{
height = tr.endpos.z - GetAbsOrigin().z;
height -= BOUNCEBOMB_RADIUS;
if ( height < 0.1 )
height = 0.1;
}
float time = sqrt( height / (0.5 * GetCurrentGravity()) );
float velocity = GetCurrentGravity() * time;
// or you can just AddVelocity to the object instead of ApplyForce
float force = velocity * pPhysicsObject->GetMass();
Vector up;
GetVectors( NULL, NULL, &up );
pPhysicsObject->Wake();
pPhysicsObject->ApplyForceCenter( up * force );
if( m_hNearestNPC )
{
Vector vecPredict = m_hNearestNPC->GetSmoothedVelocity();
pPhysicsObject->ApplyForceCenter( vecPredict * (pPhysicsObject->GetMass() * 0.65f) );
}
pPhysicsObject->ApplyTorqueCenter( AngularImpulse( random->RandomFloat( 15, 40 ), random->RandomFloat( 15, 40 ), random->RandomFloat( 30, 60 ) ) );
EmitSound( "NPC_CombineMine.Hop" );
SetThink( &CBounceBomb::ExplodeThink );
SetNextThink( gpGlobals->curtime + 0.33f );
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::CaptiveThink()
{
SetNextThink( gpGlobals->curtime + 0.05 );
StudioFrameAdvance();
float phase = fabs( sin( gpGlobals->curtime * 4.0f ) );
phase *= BOUNCEBOMB_HOOK_RANGE;
SetPoseParameter( m_iAllHooks, phase );
return;
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::SettleThink()
{
SetNextThink( gpGlobals->curtime + 0.05 );
StudioFrameAdvance();
if( GetParent() )
{
// A scanner or something is carrying me. Just keep checking back.
return;
}
// Not being carried.
if( !VPhysicsGetObject() )
{
// Probably was just dropped. Get physics going.
CreateVPhysics();
if( !VPhysicsGetObject() )
{
Msg("**** Can't create vphysics for combine_mine!\n" );
UTIL_Remove( this );
return;
}
VPhysicsGetObject()->Wake();
return;
}
if( !m_bDisarmed )
{
if( VPhysicsGetObject()->IsAsleep() && !(VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD) )
{
// If i'm not resting on the world, jump randomly.
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 1024 ), MASK_SHOT|CONTENTS_GRATE, this, COLLISION_GROUP_NONE, &tr );
bool bHop = false;
if( tr.m_pEnt )
{
IPhysicsObject *pPhysics = tr.m_pEnt->VPhysicsGetObject();
if( pPhysics && pPhysics->GetMass() <= 1000 )
{
// Light physics objects can be moved out from under the mine.
bHop = true;
}
else if( tr.m_pEnt->m_takedamage != DAMAGE_NO )
{
// Things that can be harmed can likely be broken.
bHop = true;
}
if( bHop )
{
Vector vecForce;
vecForce.x = random->RandomFloat( -1000, 1000 );
vecForce.y = random->RandomFloat( -1000, 1000 );
vecForce.z = 2500;
AngularImpulse torque( 160, 0, 160 );
Flip( vecForce, torque );
return;
}
// Check for upside-down
Vector vecUp;
GetVectors( NULL, NULL, &vecUp );
if( vecUp.z <= 0.8 )
{
// Landed upside down. Right self
Vector vecForce( 0, 0, 2500 );
Flip( vecForce, AngularImpulse( 60, 0, 0 ) );
return;
}
}
// Check to make sure I'm not in a forbidden location
if( !IsValidLocation() )
{
return;
}
// Lock to what I'm resting on
constraint_ballsocketparams_t ballsocket;
ballsocket.Defaults();
ballsocket.constraint.Defaults();
ballsocket.constraint.forceLimit = lbs2kg(1000);
ballsocket.constraint.torqueLimit = lbs2kg(1000);
ballsocket.InitWithCurrentObjectState( g_PhysWorldObject, VPhysicsGetObject(), GetAbsOrigin() );
m_pConstraint = physenv->CreateBallsocketConstraint( g_PhysWorldObject, VPhysicsGetObject(), NULL, ballsocket );
CloseHooks();
SetMineState( MINE_STATE_ARMED );
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
int CBounceBomb::OnTakeDamage( const CTakeDamageInfo &info )
{
if( m_pConstraint || !VPhysicsGetObject())
{
return false;
}
VPhysicsTakeDamage( info );
return true;
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::UpdateLight( bool bTurnOn, unsigned int r, unsigned int g, unsigned int b, unsigned int a )
{
if( bTurnOn )
{
Assert( a > 0 );
// Throw the old sprite away
if( m_hSprite )
{
UTIL_Remove( m_hSprite );
m_hSprite.Set( NULL );
}
if( !m_hSprite.Get() )
{
Vector up;
GetVectors( NULL, NULL, &up );
// Light isn't on.
m_hSprite = CSprite::SpriteCreate( "sprites/glow01.vmt", GetAbsOrigin() + up * 10.0f, false );
CSprite *pSprite = (CSprite *)m_hSprite.Get();
if( m_hSprite )
{
pSprite->SetParent( this );
pSprite->SetTransparency( kRenderTransAdd, r, g, b, a, kRenderFxNone );
pSprite->SetScale( 0.35, 0.0 );
}
}
else
{
// Update color
CSprite *pSprite = (CSprite *)m_hSprite.Get();
pSprite->SetTransparency( kRenderTransAdd, r, g, b, a, kRenderFxNone );
}
}
if( !bTurnOn )
{
if( m_hSprite )
{
UTIL_Remove( m_hSprite );
m_hSprite.Set( NULL );
}
}
if ( !m_hSprite )
{
m_LastSpriteColor.SetRawColor( 0 );
}
else
{
m_LastSpriteColor.SetColor( r, g, b, a );
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::Wake( bool bAwake )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
CReliableBroadcastRecipientFilter filter;
if( !m_pWarnSound )
{
m_pWarnSound = controller.SoundCreate( filter, entindex(), "NPC_CombineMine.ActiveLoop" );
controller.Play( m_pWarnSound, 1.0, PITCH_NORM );
}
if( bAwake )
{
// Turning on
if( m_bFoeNearest )
{
EmitSound( "NPC_CombineMine.TurnOn" );
controller.SoundChangeVolume( m_pWarnSound, 1.0, 0.1 );
}
unsigned char r, g, b;
r = g = b = 0;
if( m_bFoeNearest )
{
r = 255;
}
else
{
g = 255;
}
UpdateLight( true, r, g, b, 190 );
}
else
{
// Turning off
if( m_bFoeNearest )
{
EmitSound( "NPC_CombineMine.TurnOff" );
}
SetNearestNPC( NULL );
controller.SoundChangeVolume( m_pWarnSound, 0.0, 0.1 );
UpdateLight( false, 0, 0, 0, 0 );
}
m_bAwake = bAwake;
}
//---------------------------------------------------------
// Returns distance to the nearest BaseCombatCharacter.
//---------------------------------------------------------
float CBounceBomb::FindNearestNPC()
{
float flNearest = (BOUNCEBOMB_WARN_RADIUS * BOUNCEBOMB_WARN_RADIUS) + 1.0;
// Assume this search won't find anyone.
SetNearestNPC( NULL );
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
int nAIs = g_AI_Manager.NumAIs();
for ( int i = 0; i < nAIs; i++ )
{
CAI_BaseNPC *pNPC = ppAIs[ i ];
if( pNPC->IsAlive() )
{
// ignore hidden objects
if ( pNPC->IsEffectActive( EF_NODRAW ) )
continue;
// Don't bother with NPC's that are below me.
if( pNPC->EyePosition().z < GetAbsOrigin().z )
continue;
// Disregard things that want to be disregarded
if( pNPC->Classify() == CLASS_NONE )
continue;
// Disregard bullseyes
if( pNPC->Classify() == CLASS_BULLSEYE )
continue;
// Disregard turrets
if( pNPC->m_iClassname == gm_iszFloorTurretClassname || pNPC->m_iClassname == gm_iszGroundTurretClassname )
continue;
float flDist = (GetAbsOrigin() - pNPC->GetAbsOrigin()).LengthSqr();
if( flDist < flNearest )
{
// Now do a visibility test.
if( FVisible( pNPC, MASK_SOLID_BRUSHONLY ) )
{
flNearest = flDist;
SetNearestNPC( pNPC );
}
}
}
}
// finally, check the player.
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if( pPlayer && !(pPlayer->GetFlags() & FL_NOTARGET) )
{
float flDist = (pPlayer->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
if( flDist < flNearest && FVisible( pPlayer, MASK_SOLID_BRUSHONLY ) )
{
flNearest = flDist;
SetNearestNPC( pPlayer );
}
}
if( m_hNearestNPC.Get() )
{
// If sprite is active, update its color to reflect who is nearest.
if( IsFriend( m_hNearestNPC ) )
{
if( m_bFoeNearest )
{
// Changing state to where a friend is nearest.
if( IsFriend( m_hNearestNPC ) )
{
// Friend
UpdateLight( true, 0, 255, 0, 190 );
m_bFoeNearest = false;
}
}
}
else // it's a foe
{
if( !m_bFoeNearest )
{
// Changing state to where a foe is nearest.
UpdateLight( true, 255, 0, 0, 190 );
m_bFoeNearest = true;
}
}
}
return sqrt( flNearest );
}
//---------------------------------------------------------
//---------------------------------------------------------
bool CBounceBomb::IsFriend( CBaseEntity *pEntity )
{
int classify = pEntity->Classify();
bool bIsCombine = false;
// Unconditional enemies to combine and Player.
if( classify == CLASS_ZOMBIE || classify == CLASS_HEADCRAB || classify == CLASS_ANTLION )
{
return false;
}
if( classify == CLASS_METROPOLICE ||
classify == CLASS_COMBINE ||
classify == CLASS_MILITARY ||
classify == CLASS_COMBINE_HUNTER ||
classify == CLASS_SCANNER )
{
bIsCombine = true;
}
if( m_bPlacedByPlayer )
{
return !bIsCombine;
}
else
{
return bIsCombine;
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::SearchThink()
{
if( !UTIL_FindClientInPVS(edict()) )
{
// Sleep!
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
if( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI) )
{
if( IsAwake() )
{
Wake(false);
}
SetNextThink( gpGlobals->curtime + 0.5 );
return;
}
SetNextThink( gpGlobals->curtime + 0.1 );
StudioFrameAdvance();
if( m_pConstraint && gpGlobals->curtime - m_flTimeGrabbed >= 1.0f )
{
m_OnPulledUp.FireOutput( this, this );
SetMineState( MINE_STATE_CAPTIVE );
return;
}
float flNearestNPCDist = FindNearestNPC();
if( flNearestNPCDist <= BOUNCEBOMB_WARN_RADIUS )
{
if( !IsAwake() )
{
Wake( true );
}
}
else
{
if( IsAwake() )
{
Wake( false );
}
return;
}
if( flNearestNPCDist <= BOUNCEBOMB_DETONATE_RADIUS && !IsFriend( m_hNearestNPC ) )
{
if( m_bBounce )
{
SetMineState( MINE_STATE_TRIGGERED );
}
else
{
// Don't pop up in the air, just explode if the NPC gets closer than explode radius.
SetThink( &CBounceBomb::ExplodeThink );
SetNextThink( gpGlobals->curtime + m_flExplosionDelay );
}
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::ExplodeTouch( CBaseEntity *pOther )
{
// Don't touch anything if held by physgun.
if( m_bHeldByPhysgun )
return;
// Don't touch triggers.
if( pOther->IsSolidFlagSet(FSOLID_TRIGGER) )
return;
// Don't touch gibs and other debris
if( pOther->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
{
if( hl2_episodic.GetBool() )
{
Vector vecVelocity;
VPhysicsGetObject()->GetVelocity( &vecVelocity, NULL );
if( vecVelocity == vec3_origin )
{
ExplodeThink();
}
}
return;
}
// Don't detonate against the world if not allowed. Actually, don't
// detonate against anything that's probably not an NPC (such as physics props)
if( m_flIgnoreWorldTime > gpGlobals->curtime && !pOther->MyCombatCharacterPointer() )
{
return;
}
ExplodeThink();
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::ExplodeThink()
{
SetSolid( SOLID_NONE );
// Don't catch self in own explosion!
m_takedamage = DAMAGE_NO;
if( m_hSprite )
{
UpdateLight( false, 0, 0, 0, 0 );
}
if( m_pWarnSound )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundDestroy( m_pWarnSound );
}
CBaseEntity *pThrower = HasPhysicsAttacker( 0.5 );
if (m_iModification == MINE_MODIFICATION_CAVERN)
{
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), (pThrower) ? pThrower : this, BOUNCEBOMB_EXPLODE_DAMAGE, BOUNCEBOMB_EXPLODE_RADIUS, true,
NULL, CLASS_PLAYER_ALLY );
}
else
{
ExplosionCreate( GetAbsOrigin(), GetAbsAngles(), (pThrower) ? pThrower : this, BOUNCEBOMB_EXPLODE_DAMAGE, BOUNCEBOMB_EXPLODE_RADIUS, true);
}
UTIL_Remove( this );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::OpenHooks( bool bSilent )
{
if( !bSilent )
{
EmitSound( "NPC_CombineMine.OpenHooks" );
}
if( VPhysicsGetObject() )
{
// It's possible to not have a valid physics object here, since this function doubles as an initialization function.
PhysClearGameFlags( VPhysicsGetObject(), FVPHYSICS_CONSTRAINT_STATIC );
VPhysicsGetObject()->EnableMotion( true );
}
SetPoseParameter( m_iAllHooks, BOUNCEBOMB_HOOK_RANGE );
#ifdef _XBOX
RemoveEffects( EF_NOSHADOW );
#endif
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::CloseHooks()
{
if( !m_bLockSilently )
{
EmitSound( "NPC_CombineMine.CloseHooks" );
}
if( VPhysicsGetObject() )
{
// It's possible to not have a valid physics object here, since this function doubles as an initialization function.
PhysSetGameFlags( VPhysicsGetObject(), FVPHYSICS_CONSTRAINT_STATIC );
}
// Only lock silently the first time we call this.
m_bLockSilently = false;
SetPoseParameter( m_iAllHooks, 0 );
VPhysicsGetObject()->EnableMotion( false );
// Once I lock down, forget how many tries it took.
m_iFlipAttempts = 0;
#ifdef _XBOX
AddEffects( EF_NOSHADOW );
#endif
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::InputDisarm( inputdata_t &inputdata )
{
// Only affect a mine that's armed and not placed by player.
if( !m_bPlacedByPlayer && m_iMineState == MINE_STATE_ARMED )
{
if( m_pConstraint )
{
physenv->DestroyConstraint( m_pConstraint );
m_pConstraint = NULL;
}
m_bDisarmed = true;
OpenHooks(false);
SetMineState(MINE_STATE_DORMANT);
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
m_flTimeGrabbed = FLT_MAX;
m_bHeldByPhysgun = false;
if( m_iMineState == MINE_STATE_ARMED )
{
// Put the mine back to searching.
Wake( false );
return;
}
if( Reason == DROPPED_BY_CANNON )
{
// Set to lock down to ground again.
m_bPlacedByPlayer = true;
OpenHooks( true );
SetMineState( MINE_STATE_DEPLOY );
}
else if ( Reason == LAUNCHED_BY_CANNON )
{
SetMineState( MINE_STATE_LAUNCHED );
}
}
//---------------------------------------------------------
//---------------------------------------------------------
CBasePlayer *CBounceBomb::HasPhysicsAttacker( float dt )
{
if (gpGlobals->curtime - dt <= m_flLastPhysicsInfluenceTime)
{
return m_hPhysicsAttacker;
}
return NULL;
}
//---------------------------------------------------------
//---------------------------------------------------------
void CBounceBomb::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
m_hPhysicsAttacker = pPhysGunUser;
m_flLastPhysicsInfluenceTime = gpGlobals->curtime;
m_iFlipAttempts = 0;
if( reason != PUNTED_BY_CANNON )
{
if( m_iMineState == MINE_STATE_ARMED )
{
// Yanking on a mine that is locked down, trying to rip it loose.
UpdateLight( true, 255, 255, 0, 190 );
m_flTimeGrabbed = gpGlobals->curtime;
m_bHeldByPhysgun = true;
VPhysicsGetObject()->EnableMotion( true );
// Try to scatter NPCs without panicking them. Make a move away sound up around their
// ear level.
CSoundEnt::InsertSound( SOUND_MOVE_AWAY, GetAbsOrigin() + Vector( 0, 0, 60), 32.0f, 0.2f );
return;
}
else
{
// Picked up a mine that was not locked down.
m_bHeldByPhysgun = true;
if( m_iMineState == MINE_STATE_TRIGGERED )
{
// This mine's already set to blow. Player can't place it.
return;
}
else
{
m_bDisarmed = false;
SetMineState( MINE_STATE_DEPLOY );
}
}
}
else
{
m_bHeldByPhysgun = false;
}
if( reason == PUNTED_BY_CANNON )
{
if( m_iMineState == MINE_STATE_TRIGGERED || m_iMineState == MINE_STATE_ARMED )
{
// Already set to blow
return;
}
m_bDisarmed = false;
m_bPlacedByPlayer = true;
SetTouch( NULL );
SetThink( &CBounceBomb::SettleThink );
SetNextThink( gpGlobals->curtime + 0.1);
// Since being punted causes the mine to flip, sometimes it 'catches an edge'
// and ends up touching the ground from whence it came, exploding instantly.
// This little stunt prevents that by ignoring world collisions for a very short time.
m_flIgnoreWorldTime = gpGlobals->curtime + 0.1;
}
}
LINK_ENTITY_TO_CLASS( bounce_bomb, CBounceBomb );
LINK_ENTITY_TO_CLASS( combine_bouncemine, CBounceBomb );
LINK_ENTITY_TO_CLASS( combine_mine, CBounceBomb );
/*
*/