d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
48 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0b5a04e732
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0b5a04e732'
${ noResults }
source-engine/game/server/hl2/prop_combine_ball.cpp

2197 lines
63 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: combine ball - can be held by the super physcannon and launched
// by the AR2's alt-fire
//
//=============================================================================//
#include "cbase.h"
#include "prop_combine_ball.h"
#include "props.h"
#include "explode.h"
#include "saverestore_utlvector.h"
#include "hl2_shareddefs.h"
#include "materialsystem/imaterial.h"
#include "beam_flags.h"
#include "physics_prop_ragdoll.h"
#include "soundent.h"
#include "soundenvelope.h"
#include "te_effect_dispatch.h"
#include "ai_basenpc.h"
#include "npc_bullseye.h"
#include "filters.h"
#include "SpriteTrail.h"
#include "decals.h"
#include "hl2_player.h"
#include "eventqueue.h"
#include "physics_collisionevent.h"
#include "gamestats.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define PROP_COMBINE_BALL_MODEL "models/effects/combineball.mdl"
#define PROP_COMBINE_BALL_SPRITE_TRAIL "sprites/combineball_trail_black_1.vmt"
#define PROP_COMBINE_BALL_LIFETIME 4.0f // Seconds
#define PROP_COMBINE_BALL_HOLD_DISSOLVE_TIME 8.0f
#define SF_COMBINE_BALL_BOUNCING_IN_SPAWNER 0x10000
#define MAX_COMBINEBALL_RADIUS 12
ConVar sk_npc_dmg_combineball( "sk_npc_dmg_combineball","15", FCVAR_REPLICATED);
ConVar sk_combineball_guidefactor( "sk_combineball_guidefactor","0.5", FCVAR_REPLICATED);
ConVar sk_combine_ball_search_radius( "sk_combine_ball_search_radius", "512", FCVAR_REPLICATED);
ConVar sk_combineball_seek_angle( "sk_combineball_seek_angle","15.0", FCVAR_REPLICATED);
ConVar sk_combineball_seek_kill( "sk_combineball_seek_kill","0", FCVAR_REPLICATED);
// For our ring explosion
int s_nExplosionTexture = -1;
//-----------------------------------------------------------------------------
// Context think
//-----------------------------------------------------------------------------
static const char *s_pWhizThinkContext = "WhizThinkContext";
static const char *s_pHoldDissolveContext = "HoldDissolveContext";
static const char *s_pExplodeTimerContext = "ExplodeTimerContext";
static const char *s_pAnimThinkContext = "AnimThinkContext";
static const char *s_pCaptureContext = "CaptureContext";
static const char *s_pRemoveContext = "RemoveContext";
//-----------------------------------------------------------------------------
// Purpose:
// Input : radius -
// Output : CBaseEntity
//-----------------------------------------------------------------------------
CBaseEntity *CreateCombineBall( const Vector &origin, const Vector &velocity, float radius, float mass, float lifetime, CBaseEntity *pOwner )
{
CPropCombineBall *pBall = static_cast<CPropCombineBall*>( CreateEntityByName( "prop_combine_ball" ) );
pBall->SetRadius( radius );
pBall->SetAbsOrigin( origin );
pBall->SetOwnerEntity( pOwner );
pBall->SetOriginalOwner( pOwner );
pBall->SetAbsVelocity( velocity );
pBall->Spawn();
pBall->SetState( CPropCombineBall::STATE_THROWN );
pBall->SetSpeed( velocity.Length() );
pBall->EmitSound( "NPC_CombineBall.Launch" );
PhysSetGameFlags( pBall->VPhysicsGetObject(), FVPHYSICS_WAS_THROWN );
pBall->StartWhizSoundThink();
pBall->SetMass( mass );
pBall->StartLifetime( lifetime );
pBall->SetWeaponLaunched( true );
return pBall;
}
//-----------------------------------------------------------------------------
// Purpose: Allows game to know if the physics object should kill allies or not
//-----------------------------------------------------------------------------
CBasePlayer *CPropCombineBall::HasPhysicsAttacker( float dt )
{
// Must have an owner
if ( GetOwnerEntity() == NULL )
return NULL;
// Must be a player
if ( GetOwnerEntity()->IsPlayer() == false )
return NULL;
// We don't care about the time passed in
return static_cast<CBasePlayer *>(GetOwnerEntity());
}
//-----------------------------------------------------------------------------
// Purpose: Determines whether a physics object is a combine ball or not
// Input : *pObj - Object to test
// Output : Returns true on success, false on failure.
// Notes : This function cannot identify a combine ball that is held by
// the physcannon because any object held by the physcannon is
// COLLISIONGROUP_DEBRIS.
//-----------------------------------------------------------------------------
bool UTIL_IsCombineBall( CBaseEntity *pEntity )
{
// Must be the correct collision group
if ( pEntity->GetCollisionGroup() != HL2COLLISION_GROUP_COMBINE_BALL )
return false;
//NOTENOTE: This allows ANY combine ball to pass the test
/*
CPropCombineBall *pBall = dynamic_cast<CPropCombineBall *>(pEntity);
if ( pBall && pBall->WasWeaponLaunched() )
return false;
*/
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Determines whether a physics object is an AR2 combine ball or not
// Input : *pEntity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool UTIL_IsAR2CombineBall( CBaseEntity *pEntity )
{
// Must be the correct collision group
if ( pEntity->GetCollisionGroup() != HL2COLLISION_GROUP_COMBINE_BALL )
return false;
CPropCombineBall *pBall = dynamic_cast<CPropCombineBall *>(pEntity);
if ( pBall && pBall->WasWeaponLaunched() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Uses a deeper casting check to determine if pEntity is a combine
// ball. This function exists because the normal (much faster) check
// in UTIL_IsCombineBall() can never identify a combine ball held by
// the physcannon because the physcannon changes the held entity's
// collision group.
// Input : *pEntity - Entity to check
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool UTIL_IsCombineBallDefinite( CBaseEntity *pEntity )
{
CPropCombineBall *pBall = dynamic_cast<CPropCombineBall *>(pEntity);
return pBall != NULL;
}
//-----------------------------------------------------------------------------
//
// Spawns combine balls
//
//-----------------------------------------------------------------------------
#define SF_SPAWNER_START_DISABLED 0x1000
#define SF_SPAWNER_POWER_SUPPLY 0x2000
//-----------------------------------------------------------------------------
// Implementation of CPropCombineBall
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( prop_combine_ball, CPropCombineBall );
//-----------------------------------------------------------------------------
// Save/load:
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CPropCombineBall )
DEFINE_FIELD( m_flLastBounceTime, FIELD_TIME ),
DEFINE_FIELD( m_flRadius, FIELD_FLOAT ),
DEFINE_FIELD( m_nState, FIELD_CHARACTER ),
DEFINE_FIELD( m_pGlowTrail, FIELD_CLASSPTR ),
DEFINE_SOUNDPATCH( m_pHoldingSound ),
DEFINE_FIELD( m_bFiredGrabbedOutput, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bEmit, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bHeld, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bLaunched, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bStruckEntity, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bWeaponLaunched, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bForward, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flSpeed, FIELD_FLOAT ),
DEFINE_FIELD( m_flNextDamageTime, FIELD_TIME ),
DEFINE_FIELD( m_flLastCaptureTime, FIELD_TIME ),
DEFINE_FIELD( m_bCaptureInProgress, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nBounceCount, FIELD_INTEGER ),
DEFINE_FIELD( m_nMaxBounces, FIELD_INTEGER ),
DEFINE_FIELD( m_bBounceDie, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hSpawner, FIELD_EHANDLE ),
DEFINE_THINKFUNC( ExplodeThink ),
DEFINE_THINKFUNC( WhizSoundThink ),
DEFINE_THINKFUNC( DieThink ),
DEFINE_THINKFUNC( DissolveThink ),
DEFINE_THINKFUNC( DissolveRampSoundThink ),
DEFINE_THINKFUNC( AnimThink ),
DEFINE_THINKFUNC( CaptureBySpawner ),
DEFINE_INPUTFUNC( FIELD_VOID, "Explode", InputExplode ),
DEFINE_INPUTFUNC( FIELD_VOID, "FadeAndRespawn", InputFadeAndRespawn ),
DEFINE_INPUTFUNC( FIELD_VOID, "Kill", InputKill ),
DEFINE_INPUTFUNC( FIELD_VOID, "Socketed", InputSocketed ),
END_DATADESC()
IMPLEMENT_SERVERCLASS_ST( CPropCombineBall, DT_PropCombineBall )
SendPropBool( SENDINFO( m_bEmit ) ),
SendPropFloat( SENDINFO( m_flRadius ), 0, SPROP_NOSCALE ),
SendPropBool( SENDINFO( m_bHeld ) ),
SendPropBool( SENDINFO( m_bLaunched ) ),
END_SEND_TABLE()
//-----------------------------------------------------------------------------
// Gets at the spawner
//-----------------------------------------------------------------------------
CFuncCombineBallSpawner *CPropCombineBall::GetSpawner()
{
return m_hSpawner;
}
//-----------------------------------------------------------------------------
// Precache
//-----------------------------------------------------------------------------
void CPropCombineBall::Precache( void )
{
//NOTENOTE: We don't call into the base class because it chains multiple
// precaches we don't need to incur
PrecacheModel( PROP_COMBINE_BALL_MODEL );
PrecacheModel( PROP_COMBINE_BALL_SPRITE_TRAIL );
s_nExplosionTexture = PrecacheModel( "sprites/lgtning.vmt" );
PrecacheScriptSound( "NPC_CombineBall.Launch" );
PrecacheScriptSound( "NPC_CombineBall.KillImpact" );
if ( hl2_episodic.GetBool() )
{
PrecacheScriptSound( "NPC_CombineBall_Episodic.Explosion" );
PrecacheScriptSound( "NPC_CombineBall_Episodic.WhizFlyby" );
PrecacheScriptSound( "NPC_CombineBall_Episodic.Impact" );
}
else
{
PrecacheScriptSound( "NPC_CombineBall.Explosion" );
PrecacheScriptSound( "NPC_CombineBall.WhizFlyby" );
PrecacheScriptSound( "NPC_CombineBall.Impact" );
}
PrecacheScriptSound( "NPC_CombineBall.HoldingInPhysCannon" );
}
//-----------------------------------------------------------------------------
// Spherical vphysics
//-----------------------------------------------------------------------------
bool CPropCombineBall::OverridePropdata()
{
return true;
}
//-----------------------------------------------------------------------------
// Spherical vphysics
//-----------------------------------------------------------------------------
void CPropCombineBall::SetState( int state )
{
if ( m_nState != state )
{
if ( m_nState == STATE_NOT_THROWN )
{
m_flLastCaptureTime = gpGlobals->curtime;
}
m_nState = state;
}
}
bool CPropCombineBall::IsInField() const
{
return (m_nState == STATE_NOT_THROWN);
}
//-----------------------------------------------------------------------------
// Sets the radius
//-----------------------------------------------------------------------------
void CPropCombineBall::SetRadius( float flRadius )
{
m_flRadius = clamp( flRadius, 1, MAX_COMBINEBALL_RADIUS );
}
//-----------------------------------------------------------------------------
// Create vphysics
//-----------------------------------------------------------------------------
bool CPropCombineBall::CreateVPhysics()
{
SetSolid( SOLID_BBOX );
float flSize = m_flRadius;
SetCollisionBounds( Vector(-flSize, -flSize, -flSize), Vector(flSize, flSize, flSize) );
objectparams_t params = g_PhysDefaultObjectParams;
params.pGameData = static_cast<void *>(this);
int nMaterialIndex = physprops->GetSurfaceIndex("metal_bouncy");
IPhysicsObject *pPhysicsObject = physenv->CreateSphereObject( flSize, nMaterialIndex, GetAbsOrigin(), GetAbsAngles(), &params, false );
if ( !pPhysicsObject )
return false;
VPhysicsSetObject( pPhysicsObject );
SetMoveType( MOVETYPE_VPHYSICS );
pPhysicsObject->Wake();
pPhysicsObject->SetMass( 750.0f );
pPhysicsObject->EnableGravity( false );
pPhysicsObject->EnableDrag( false );
float flDamping = 0.0f;
float flAngDamping = 0.5f;
pPhysicsObject->SetDamping( &flDamping, &flAngDamping );
pPhysicsObject->SetInertia( Vector( 1e30, 1e30, 1e30 ) );
if( WasFiredByNPC() )
{
// Don't do impact damage. Just touch them and do your dissolve damage and move on.
PhysSetGameFlags( pPhysicsObject, FVPHYSICS_NO_NPC_IMPACT_DMG );
}
else
{
PhysSetGameFlags( pPhysicsObject, FVPHYSICS_DMG_DISSOLVE | FVPHYSICS_HEAVY_OBJECT );
}
return true;
}
//-----------------------------------------------------------------------------
// Spawn:
//-----------------------------------------------------------------------------
void CPropCombineBall::Spawn( void )
{
BaseClass::Spawn();
SetModel( PROP_COMBINE_BALL_MODEL );
if( ShouldHitPlayer() )
{
// This allows the combine ball to hit the player.
SetCollisionGroup( HL2COLLISION_GROUP_COMBINE_BALL_NPC );
}
else
{
SetCollisionGroup( HL2COLLISION_GROUP_COMBINE_BALL );
}
CreateVPhysics();
Vector vecAbsVelocity = GetAbsVelocity();
VPhysicsGetObject()->SetVelocity( &vecAbsVelocity, NULL );
m_nState = STATE_NOT_THROWN;
m_flLastBounceTime = -1.0f;
m_bFiredGrabbedOutput = false;
m_bForward = true;
m_bCaptureInProgress = false;
// No shadow!
AddEffects( EF_NOSHADOW );
// Start up the eye trail
m_pGlowTrail = CSpriteTrail::SpriteTrailCreate( PROP_COMBINE_BALL_SPRITE_TRAIL, GetAbsOrigin(), false );
if ( m_pGlowTrail != NULL )
{
m_pGlowTrail->FollowEntity( this );
m_pGlowTrail->SetTransparency( kRenderTransAdd, 0, 0, 0, 255, kRenderFxNone );
m_pGlowTrail->SetStartWidth( m_flRadius );
m_pGlowTrail->SetEndWidth( 0 );
m_pGlowTrail->SetLifeTime( 0.1f );
m_pGlowTrail->TurnOff();
}
m_bEmit = true;
m_bHeld = false;
m_bLaunched = false;
m_bStruckEntity = false;
m_bWeaponLaunched = false;
m_flNextDamageTime = gpGlobals->curtime;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::StartAnimating( void )
{
// Start our animation cycle. Use the random to avoid everything thinking the same frame
SetContextThink( &CPropCombineBall::AnimThink, gpGlobals->curtime + random->RandomFloat( 0.0f, 0.1f), s_pAnimThinkContext );
int nSequence = LookupSequence( "idle" );
SetCycle( 0 );
m_flAnimTime = gpGlobals->curtime;
ResetSequence( nSequence );
ResetClientsideFrame();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::StopAnimating( void )
{
SetContextThink( NULL, gpGlobals->curtime, s_pAnimThinkContext );
}
//-----------------------------------------------------------------------------
// Put it into the spawner
//-----------------------------------------------------------------------------
void CPropCombineBall::CaptureBySpawner( )
{
m_bCaptureInProgress = true;
m_bFiredGrabbedOutput = false;
// Slow down the ball
Vector vecVelocity;
VPhysicsGetObject()->GetVelocity( &vecVelocity, NULL );
float flSpeed = VectorNormalize( vecVelocity );
if ( flSpeed > 25.0f )
{
vecVelocity *= flSpeed * 0.4f;
VPhysicsGetObject()->SetVelocity( &vecVelocity, NULL );
// Slow it down until we can set its velocity ok
SetContextThink( &CPropCombineBall::CaptureBySpawner, gpGlobals->curtime + 0.01f, s_pCaptureContext );
return;
}
// Ok, we're captured
SetContextThink( NULL, gpGlobals->curtime, s_pCaptureContext );
ReplaceInSpawner( GetSpawner()->GetBallSpeed() );
m_bCaptureInProgress = false;
}
//-----------------------------------------------------------------------------
// Put it into the spawner
//-----------------------------------------------------------------------------
void CPropCombineBall::ReplaceInSpawner( float flSpeed )
{
m_bForward = true;
m_nState = STATE_NOT_THROWN;
// Prevent it from exploding
ClearLifetime( );
// Stop whiz noises
SetContextThink( NULL, gpGlobals->curtime, s_pWhizThinkContext );
// Slam velocity to what the field wants
Vector vecTarget, vecVelocity;
GetSpawner()->GetTargetEndpoint( m_bForward, &vecTarget );
VectorSubtract( vecTarget, GetAbsOrigin(), vecVelocity );
VectorNormalize( vecVelocity );
vecVelocity *= flSpeed;
VPhysicsGetObject()->SetVelocity( &vecVelocity, NULL );
// Set our desired speed to the spawner's speed. This will be
// our speed on our first bounce in the field.
SetSpeed( flSpeed );
}
float CPropCombineBall::LastCaptureTime() const
{
if ( IsInField() || IsBeingCaptured() )
return gpGlobals->curtime;
return m_flLastCaptureTime;
}
//-----------------------------------------------------------------------------
// Purpose: Starts the lifetime countdown on the ball
// Input : flDuration - number of seconds to live before exploding
//-----------------------------------------------------------------------------
void CPropCombineBall::StartLifetime( float flDuration )
{
SetContextThink( &CPropCombineBall::ExplodeThink, gpGlobals->curtime + flDuration, s_pExplodeTimerContext );
}
//-----------------------------------------------------------------------------
// Purpose: Stops the lifetime on the ball from expiring
//-----------------------------------------------------------------------------
void CPropCombineBall::ClearLifetime( void )
{
// Prevent it from exploding
SetContextThink( NULL, gpGlobals->curtime, s_pExplodeTimerContext );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mass -
//-----------------------------------------------------------------------------
void CPropCombineBall::SetMass( float mass )
{
IPhysicsObject *pObj = VPhysicsGetObject();
if ( pObj != NULL )
{
pObj->SetMass( mass );
pObj->SetInertia( Vector( 500, 500, 500 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CPropCombineBall::ShouldHitPlayer() const
{
if ( GetOwnerEntity() )
{
CAI_BaseNPC *pNPC = GetOwnerEntity()->MyNPCPointer();
if ( pNPC && !pNPC->IsPlayerAlly() )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::InputKill( inputdata_t &inputdata )
{
// tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality.
CBaseEntity *pOwner = GetOwnerEntity();
if ( pOwner )
{
pOwner->DeathNotice( this );
SetOwnerEntity( NULL );
}
UTIL_Remove( this );
NotifySpawnerOfRemoval();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::InputSocketed( inputdata_t &inputdata )
{
// tell owner ( if any ) that we're dead.This is mostly for NPCMaker functionality.
CBaseEntity *pOwner = GetOwnerEntity();
if ( pOwner )
{
pOwner->DeathNotice( this );
SetOwnerEntity( NULL );
}
// if our owner is a player, tell them we were socketed
CHL2_Player *pPlayer = dynamic_cast<CHL2_Player *>( pOwner );
if ( pPlayer )
{
pPlayer->CombineBallSocketed( this );
}
UTIL_Remove( this );
NotifySpawnerOfRemoval();
}
//-----------------------------------------------------------------------------
// Cleanup.
//-----------------------------------------------------------------------------
void CPropCombineBall::UpdateOnRemove()
{
if ( m_pGlowTrail != NULL )
{
UTIL_Remove( m_pGlowTrail );
m_pGlowTrail = NULL;
}
//Sigh... this is the only place where I can get a message after the ball is done dissolving.
if ( hl2_episodic.GetBool() )
{
if ( IsDissolving() )
{
if ( GetSpawner() )
{
GetSpawner()->BallGrabbed( this );
NotifySpawnerOfRemoval();
}
}
}
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::ExplodeThink( void )
{
DoExplosion();
}
//-----------------------------------------------------------------------------
// Purpose: Tell the respawner to make a new one
//-----------------------------------------------------------------------------
void CPropCombineBall::NotifySpawnerOfRemoval( void )
{
if ( GetSpawner() )
{
GetSpawner()->RespawnBallPostExplosion();
}
}
//-----------------------------------------------------------------------------
// Fade out.
//-----------------------------------------------------------------------------
void CPropCombineBall::DieThink()
{
if ( GetSpawner() )
{
//Let the spawner know we died so it does it's thing
if( hl2_episodic.GetBool() && IsInField() )
{
GetSpawner()->BallGrabbed( this );
}
GetSpawner()->RespawnBall( 0.1 );
}
UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
// Fade out.
//-----------------------------------------------------------------------------
void CPropCombineBall::FadeOut( float flDuration )
{
AddSolidFlags( FSOLID_NOT_SOLID );
// Start up the eye trail
if ( m_pGlowTrail != NULL )
{
m_pGlowTrail->SetBrightness( 0, flDuration );
}
SetThink( &CPropCombineBall::DieThink );
SetNextThink( gpGlobals->curtime + flDuration );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::StartWhizSoundThink( void )
{
SetContextThink( &CPropCombineBall::WhizSoundThink, gpGlobals->curtime + 2.0f * TICK_INTERVAL, s_pWhizThinkContext );
}
//-----------------------------------------------------------------------------
// Danger sounds.
//-----------------------------------------------------------------------------
void CPropCombineBall::WhizSoundThink()
{
Vector vecPosition, vecVelocity;
IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
if ( pPhysicsObject == NULL )
{
//NOTENOTE: We should always have been created at this point
Assert( 0 );
SetContextThink( &CPropCombineBall::WhizSoundThink, gpGlobals->curtime + 2.0f * TICK_INTERVAL, s_pWhizThinkContext );
return;
}
pPhysicsObject->GetPosition( &vecPosition, NULL );
pPhysicsObject->GetVelocity( &vecVelocity, NULL );
if ( gpGlobals->maxClients == 1 )
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if ( pPlayer )
{
Vector vecDelta;
VectorSubtract( pPlayer->GetAbsOrigin(), vecPosition, vecDelta );
VectorNormalize( vecDelta );
if ( DotProduct( vecDelta, vecVelocity ) > 0.5f )
{
Vector vecEndPoint;
VectorMA( vecPosition, 2.0f * TICK_INTERVAL, vecVelocity, vecEndPoint );
float flDist = CalcDistanceToLineSegment( pPlayer->GetAbsOrigin(), vecPosition, vecEndPoint );
if ( flDist < 200.0f )
{
CPASAttenuationFilter filter( vecPosition, ATTN_NORM );
EmitSound_t ep;
ep.m_nChannel = CHAN_STATIC;
if ( hl2_episodic.GetBool() )
{
ep.m_pSoundName = "NPC_CombineBall_Episodic.WhizFlyby";
}
else
{
ep.m_pSoundName = "NPC_CombineBall.WhizFlyby";
}
ep.m_flVolume = 1.0f;
ep.m_SoundLevel = SNDLVL_NORM;
EmitSound( filter, entindex(), ep );
SetContextThink( &CPropCombineBall::WhizSoundThink, gpGlobals->curtime + 0.5f, s_pWhizThinkContext );
return;
}
}
}
}
SetContextThink( &CPropCombineBall::WhizSoundThink, gpGlobals->curtime + 2.0f * TICK_INTERVAL, s_pWhizThinkContext );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::SetBallAsLaunched( void )
{
// Give the ball a duration
StartLifetime( PROP_COMBINE_BALL_LIFETIME );
m_bHeld = false;
m_bLaunched = true;
SetState( STATE_THROWN );
VPhysicsGetObject()->SetMass( 750.0f );
VPhysicsGetObject()->SetInertia( Vector( 1e30, 1e30, 1e30 ) );
StopLoopingSounds();
EmitSound( "NPC_CombineBall.Launch" );
WhizSoundThink();
}
//-----------------------------------------------------------------------------
// Lighten the mass so it's zippy toget to the gun
//-----------------------------------------------------------------------------
void CPropCombineBall::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
CDefaultPlayerPickupVPhysics::OnPhysGunPickup( pPhysGunUser, reason );
if ( m_nMaxBounces == -1 )
{
m_nMaxBounces = 0;
}
if ( !m_bFiredGrabbedOutput )
{
if ( GetSpawner() )
{
GetSpawner()->BallGrabbed( this );
}
m_bFiredGrabbedOutput = true;
}
if ( m_pGlowTrail )
{
m_pGlowTrail->TurnOff();
m_pGlowTrail->SetRenderColor( 0, 0, 0, 0 );
}
if ( reason != PUNTED_BY_CANNON )
{
SetState( STATE_HOLDING );
CPASAttenuationFilter filter( GetAbsOrigin(), ATTN_NORM );
filter.MakeReliable();
EmitSound_t ep;
ep.m_nChannel = CHAN_STATIC;
if( hl2_episodic.GetBool() )
{
ep.m_pSoundName = "NPC_CombineBall_Episodic.HoldingInPhysCannon";
}
else
{
ep.m_pSoundName = "NPC_CombineBall.HoldingInPhysCannon";
}
ep.m_flVolume = 1.0f;
ep.m_SoundLevel = SNDLVL_NORM;
// Now we own this ball
SetPlayerLaunched( pPhysGunUser );
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
m_pHoldingSound = controller.SoundCreate( filter, entindex(), ep );
controller.Play( m_pHoldingSound, 1.0f, 100 );
// Don't collide with anything we may have to pull the ball through
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
VPhysicsGetObject()->SetMass( 20.0f );
VPhysicsGetObject()->SetInertia( Vector( 100, 100, 100 ) );
// Make it not explode
ClearLifetime( );
m_bHeld = true;
m_bLaunched = false;
//Let the ball know is not being captured by one of those ball fields anymore.
//
m_bCaptureInProgress = false;
SetContextThink( &CPropCombineBall::DissolveRampSoundThink, gpGlobals->curtime + GetBallHoldSoundRampTime(), s_pHoldDissolveContext );
StartAnimating();
}
else
{
Vector vecVelocity;
VPhysicsGetObject()->GetVelocity( &vecVelocity, NULL );
SetSpeed( vecVelocity.Length() );
// Set us as being launched by the player
SetPlayerLaunched( pPhysGunUser );
SetBallAsLaunched();
StopAnimating();
}
}
//-----------------------------------------------------------------------------
// Purpose: Reset the ball to be deadly to NPCs after we've picked it up
//-----------------------------------------------------------------------------
void CPropCombineBall::SetPlayerLaunched( CBasePlayer *pOwner )
{
// Now we own this ball
SetOwnerEntity( pOwner );
SetWeaponLaunched( false );
if( VPhysicsGetObject() )
{
PhysClearGameFlags( VPhysicsGetObject(), FVPHYSICS_NO_NPC_IMPACT_DMG );
PhysSetGameFlags( VPhysicsGetObject(), FVPHYSICS_DMG_DISSOLVE | FVPHYSICS_HEAVY_OBJECT );
}
}
//-----------------------------------------------------------------------------
// Activate death-spin!
//-----------------------------------------------------------------------------
void CPropCombineBall::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
CDefaultPlayerPickupVPhysics::OnPhysGunDrop( pPhysGunUser, Reason );
SetState( STATE_THROWN );
WhizSoundThink();
m_bHeld = false;
m_bLaunched = true;
// Stop with the dissolving
SetContextThink( NULL, gpGlobals->curtime, s_pHoldDissolveContext );
// We're ready to start colliding again.
SetCollisionGroup( HL2COLLISION_GROUP_COMBINE_BALL );
if ( m_pGlowTrail )
{
m_pGlowTrail->TurnOn();
m_pGlowTrail->SetRenderColor( 255, 255, 255, 255 );
}
// Set our desired speed to be launched at
SetSpeed( 1500.0f );
SetPlayerLaunched( pPhysGunUser );
if ( Reason != LAUNCHED_BY_CANNON )
{
// Choose a random direction (forward facing)
Vector vecForward;
pPhysGunUser->GetVectors( &vecForward, NULL, NULL );
QAngle shotAng;
VectorAngles( vecForward, shotAng );
// Offset by some small cone
shotAng[PITCH] += random->RandomInt( -55, 55 );
shotAng[YAW] += random->RandomInt( -55, 55 );
AngleVectors( shotAng, &vecForward, NULL, NULL );
vecForward *= GetSpeed();
VPhysicsGetObject()->SetVelocity( &vecForward, &vec3_origin );
}
else
{
// This will have the consequence of making it so that the
// ball is launched directly down the crosshair even if the player is moving.
VPhysicsGetObject()->SetVelocity( &vec3_origin, &vec3_origin );
}
SetBallAsLaunched();
StopAnimating();
}
//------------------------------------------------------------------------------
// Stop looping sounds
//------------------------------------------------------------------------------
void CPropCombineBall::StopLoopingSounds()
{
if ( m_pHoldingSound )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.Shutdown( m_pHoldingSound );
controller.SoundDestroy( m_pHoldingSound );
m_pHoldingSound = NULL;
}
}
//------------------------------------------------------------------------------
// Pow!
//------------------------------------------------------------------------------
void CPropCombineBall::DissolveRampSoundThink( )
{
float dt = GetBallHoldDissolveTime() - GetBallHoldSoundRampTime();
if ( m_pHoldingSound )
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
controller.SoundChangePitch( m_pHoldingSound, 150, dt );
}
SetContextThink( &CPropCombineBall::DissolveThink, gpGlobals->curtime + dt, s_pHoldDissolveContext );
}
//------------------------------------------------------------------------------
// Pow!
//------------------------------------------------------------------------------
void CPropCombineBall::DissolveThink( )
{
DoExplosion();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CPropCombineBall::GetBallHoldDissolveTime()
{
float flDissolveTime = PROP_COMBINE_BALL_HOLD_DISSOLVE_TIME;
if( g_pGameRules->IsSkillLevel( 1 ) && hl2_episodic.GetBool() )
{
// Give players more time to handle/aim combine balls on Easy.
flDissolveTime *= 1.5f;
}
return flDissolveTime;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CPropCombineBall::GetBallHoldSoundRampTime()
{
return GetBallHoldDissolveTime() - 1.0f;
}
//------------------------------------------------------------------------------
// Pow!
//------------------------------------------------------------------------------
void CPropCombineBall::DoExplosion( )
{
// don't do this twice
if ( GetMoveType() == MOVETYPE_NONE )
return;
if ( PhysIsInCallback() )
{
g_PostSimulationQueue.QueueCall( this, &CPropCombineBall::DoExplosion );
return;
}
// Tell the respawner to make a new one
if ( GetSpawner() )
{
GetSpawner()->RespawnBallPostExplosion();
}
//Shockring
CBroadcastRecipientFilter filter2;
if ( OutOfBounces() == false )
{
if ( hl2_episodic.GetBool() )
{
EmitSound( "NPC_CombineBall_Episodic.Explosion" );
}
else
{
EmitSound( "NPC_CombineBall.Explosion" );
}
UTIL_ScreenShake( GetAbsOrigin(), 20.0f, 150.0, 1.0, 1250.0f, SHAKE_START );
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
DispatchEffect( "cball_explode", data );
te->BeamRingPoint( filter2, 0, GetAbsOrigin(), //origin
m_flRadius, //start radius
1024, //end radius
s_nExplosionTexture, //texture
0, //halo index
0, //start frame
2, //framerate
0.2f, //life
64, //width
0, //spread
0, //amplitude
255, //r
255, //g
225, //b
32, //a
0, //speed
FBEAM_FADEOUT
);
//Shockring
te->BeamRingPoint( filter2, 0, GetAbsOrigin(), //origin
m_flRadius, //start radius
1024, //end radius
s_nExplosionTexture, //texture
0, //halo index
0, //start frame
2, //framerate
0.5f, //life
64, //width
0, //spread
0, //amplitude
255, //r
255, //g
225, //b
64, //a
0, //speed
FBEAM_FADEOUT
);
}
else
{
//Shockring
te->BeamRingPoint( filter2, 0, GetAbsOrigin(), //origin
128, //start radius
384, //end radius
s_nExplosionTexture, //texture
0, //halo index
0, //start frame
2, //framerate
0.25f, //life
48, //width
0, //spread
0, //amplitude
255, //r
255, //g
225, //b
64, //a
0, //speed
FBEAM_FADEOUT
);
}
if( hl2_episodic.GetBool() )
{
CSoundEnt::InsertSound( SOUND_COMBAT | SOUND_CONTEXT_EXPLOSION, WorldSpaceCenter(), 180.0f, 0.25, this );
}
// Turn us off and wait because we need our trails to finish up properly
SetAbsVelocity( vec3_origin );
SetMoveType( MOVETYPE_NONE );
AddSolidFlags( FSOLID_NOT_SOLID );
m_bEmit = false;
if( !m_bStruckEntity && hl2_episodic.GetBool() && GetOwnerEntity() != NULL )
{
// Notify the player proxy that this combine ball missed so that it can fire an output.
CHL2_Player *pPlayer = dynamic_cast<CHL2_Player *>( GetOwnerEntity() );
if ( pPlayer )
{
pPlayer->MissedAR2AltFire();
}
}
SetContextThink( &CPropCombineBall::SUB_Remove, gpGlobals->curtime + 0.5f, s_pRemoveContext );
StopLoopingSounds();
}
//-----------------------------------------------------------------------------
// Enable/disable
//-----------------------------------------------------------------------------
void CPropCombineBall::InputExplode( inputdata_t &inputdata )
{
DoExplosion();
}
//-----------------------------------------------------------------------------
// Enable/disable
//-----------------------------------------------------------------------------
void CPropCombineBall::InputFadeAndRespawn( inputdata_t &inputdata )
{
FadeOut( 0.1f );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::CollisionEventToTrace( int index, gamevcollisionevent_t *pEvent, trace_t &tr )
{
UTIL_ClearTrace( tr );
pEvent->pInternalData->GetSurfaceNormal( tr.plane.normal );
pEvent->pInternalData->GetContactPoint( tr.endpos );
tr.plane.dist = DotProduct( tr.plane.normal, tr.endpos );
VectorMA( tr.endpos, -1.0f, pEvent->preVelocity[index], tr.startpos );
tr.m_pEnt = pEvent->pEntities[!index];
tr.fraction = 0.01f; // spoof!
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CPropCombineBall::DissolveEntity( CBaseEntity *pEntity )
{
if( pEntity->IsEFlagSet( EFL_NO_DISSOLVE ) )
return false;
#ifdef HL2MP
if ( pEntity->IsPlayer() )
{
m_bStruckEntity = true;
return false;
}
#endif
if( !pEntity->IsNPC() && !(dynamic_cast<CRagdollProp*>(pEntity)) )
return false;
pEntity->GetBaseAnimating()->Dissolve( "", gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
// Note that we've struck an entity
m_bStruckEntity = true;
// Force an NPC to not drop their weapon if dissolved
// CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pEntity );
// if ( pBCC != NULL )
// {
// pEntity->AddSpawnFlags( SF_NPC_NO_WEAPON_DROP );
// }
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::OnHitEntity( CBaseEntity *pHitEntity, float flSpeed, int index, gamevcollisionevent_t *pEvent )
{
// Detonate on the strider + the bone followers in the strider
if ( FClassnameIs( pHitEntity, "npc_strider" ) ||
(pHitEntity->GetOwnerEntity() && FClassnameIs( pHitEntity->GetOwnerEntity(), "npc_strider" )) )
{
DoExplosion();
return;
}
CTakeDamageInfo info( this, GetOwnerEntity(), GetAbsVelocity(), GetAbsOrigin(), sk_npc_dmg_combineball.GetFloat(), DMG_DISSOLVE );
bool bIsDissolving = (pHitEntity->GetFlags() & FL_DISSOLVING) != 0;
bool bShouldHit = pHitEntity->PassesDamageFilter( info );
//One more check
//Combine soldiers are not allowed to hurt their friends with combine balls (they can still shoot and hurt each other with grenades).
CBaseCombatCharacter *pBCC = pHitEntity->MyCombatCharacterPointer();
if ( pBCC )
{
bShouldHit = pBCC->IRelationType( GetOwnerEntity() ) != D_LI;
}
if ( !bIsDissolving && bShouldHit == true )
{
if ( pHitEntity->PassesDamageFilter( info ) )
{
if( WasFiredByNPC() || m_nMaxBounces == -1 )
{
// Since Combine balls fired by NPCs do a metered dose of damage per impact, we have to ignore touches
// for a little while after we hit someone, or the ball will immediately touch them again and do more
// damage.
if( gpGlobals->curtime >= m_flNextDamageTime )
{
EmitSound( "NPC_CombineBall.KillImpact" );
if ( pHitEntity->IsNPC() && pHitEntity->Classify() != CLASS_PLAYER_ALLY_VITAL && hl2_episodic.GetBool() == true )
{
if ( pHitEntity->Classify() != CLASS_PLAYER_ALLY || ( pHitEntity->Classify() == CLASS_PLAYER_ALLY && m_bStruckEntity == false ) )
{
info.SetDamage( pHitEntity->GetMaxHealth() );
m_bStruckEntity = true;
}
}
else
{
// Ignore touches briefly.
m_flNextDamageTime = gpGlobals->curtime + 0.1f;
}
pHitEntity->TakeDamage( info );
}
}
else
{
if ( (m_nState == STATE_THROWN) && (pHitEntity->IsNPC() || dynamic_cast<CRagdollProp*>(pHitEntity) ))
{
EmitSound( "NPC_CombineBall.KillImpact" );
}
if ( (m_nState != STATE_HOLDING) )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwnerEntity() );
if ( pPlayer && UTIL_IsAR2CombineBall( this ) && ToBaseCombatCharacter( pHitEntity ) )
{
gamestats->Event_WeaponHit( pPlayer, false, "weapon_ar2", info );
}
DissolveEntity( pHitEntity );
if ( pHitEntity->ClassMatches( "npc_hunter" ) )
{
DoExplosion();
return;
}
}
}
}
}
Vector vecFinalVelocity;
if ( IsInField() )
{
// Don't deflect when in a spawner field
vecFinalVelocity = pEvent->preVelocity[index];
}
else
{
// Don't slow down when hitting other entities.
vecFinalVelocity = pEvent->postVelocity[index];
VectorNormalize( vecFinalVelocity );
vecFinalVelocity *= GetSpeed();
}
PhysCallbackSetVelocity( pEvent->pObjects[index], vecFinalVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::DoImpactEffect( const Vector &preVelocity, int index, gamevcollisionevent_t *pEvent )
{
// Do that crazy impact effect!
trace_t tr;
CollisionEventToTrace( !index, pEvent, tr );
CBaseEntity *pTraceEntity = pEvent->pEntities[index];
UTIL_TraceLine( tr.startpos - preVelocity * 2.0f, tr.startpos + preVelocity * 2.0f, MASK_SOLID, pTraceEntity, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0f )
{
// See if we hit the sky
if ( tr.surface.flags & SURF_SKY )
{
DoExplosion();
return;
}
// Send the effect over
CEffectData data;
data.m_flRadius = 16;
data.m_vNormal = tr.plane.normal;
data.m_vOrigin = tr.endpos + tr.plane.normal * 1.0f;
DispatchEffect( "cball_bounce", data );
}
if ( hl2_episodic.GetBool() )
{
EmitSound( "NPC_CombineBall_Episodic.Impact" );
}
else
{
EmitSound( "NPC_CombineBall.Impact" );
}
}
//-----------------------------------------------------------------------------
// Tells whether this combine ball should consider deflecting towards this entity.
//-----------------------------------------------------------------------------
bool CPropCombineBall::IsAttractiveTarget( CBaseEntity *pEntity )
{
if ( !pEntity->IsAlive() )
return false;
if ( pEntity->GetFlags() & EF_NODRAW )
return false;
// Don't guide toward striders
if ( FClassnameIs( pEntity, "npc_strider" ) )
return false;
if( WasFiredByNPC() )
{
// Fired by an NPC
if( !pEntity->IsNPC() && !pEntity->IsPlayer() )
return false;
// Don't seek entities of the same class.
if ( pEntity->m_iClassname == GetOwnerEntity()->m_iClassname )
return false;
}
else
{
#ifndef HL2MP
if ( GetOwnerEntity() )
{
// Things we check if this ball has an owner that's not an NPC.
if( GetOwnerEntity()->IsPlayer() )
{
if( pEntity->Classify() == CLASS_PLAYER ||
pEntity->Classify() == CLASS_PLAYER_ALLY ||
pEntity->Classify() == CLASS_PLAYER_ALLY_VITAL )
{
// Not attracted to other players or allies.
return false;
}
}
}
// The default case.
if ( !pEntity->IsNPC() )
return false;
if( pEntity->Classify() == CLASS_BULLSEYE )
return false;
#else
if ( pEntity->IsPlayer() == false )
return false;
if ( pEntity == GetOwnerEntity() )
return false;
//No tracking teammates in teammode!
if ( g_pGameRules->IsTeamplay() )
{
if ( g_pGameRules->PlayerRelationship( GetOwnerEntity(), pEntity ) == GR_TEAMMATE )
return false;
}
#endif
// We must be able to hit them
trace_t tr;
UTIL_TraceLine( WorldSpaceCenter(), pEntity->BodyTarget( WorldSpaceCenter() ), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0f && tr.m_pEnt != pEntity )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Deflects the ball toward enemies in case of a collision
//-----------------------------------------------------------------------------
void CPropCombineBall::DeflectTowardEnemy( float flSpeed, int index, gamevcollisionevent_t *pEvent )
{
// Bounce toward a particular enemy; choose one that's closest to my new velocity.
Vector vecVelDir = pEvent->postVelocity[index];
VectorNormalize( vecVelDir );
CBaseEntity *pBestTarget = NULL;
Vector vecStartPoint;
pEvent->pInternalData->GetContactPoint( vecStartPoint );
float flBestDist = MAX_COORD_FLOAT;
CBaseEntity *list[1024];
Vector vecDelta;
float distance, flDot;
// If we've already hit something, get accurate
bool bSeekKill = m_bStruckEntity && (WasWeaponLaunched() || sk_combineball_seek_kill.GetInt() );
if ( bSeekKill )
{
int nCount = UTIL_EntitiesInSphere( list, 1024, GetAbsOrigin(), sk_combine_ball_search_radius.GetFloat(), FL_NPC | FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
if ( !IsAttractiveTarget( list[i] ) )
continue;
VectorSubtract( list[i]->WorldSpaceCenter(), vecStartPoint, vecDelta );
distance = VectorNormalize( vecDelta );
if ( distance < flBestDist )
{
// Check our direction
if ( DotProduct( vecDelta, vecVelDir ) > 0.0f )
{
pBestTarget = list[i];
flBestDist = distance;
}
}
}
}
else
{
float flMaxDot = 0.966f;
if ( !WasWeaponLaunched() )
{
float flMaxDot = sk_combineball_seek_angle.GetFloat();
float flGuideFactor = sk_combineball_guidefactor.GetFloat();
for ( int i = m_nBounceCount; --i >= 0; )
{
flMaxDot *= flGuideFactor;
}
flMaxDot = cos( flMaxDot * M_PI / 180.0f );
if ( flMaxDot > 1.0f )
{
flMaxDot = 1.0f;
}
}
// Otherwise only help out a little
Vector extents = Vector(256, 256, 256);
Ray_t ray;
ray.Init( vecStartPoint, vecStartPoint + 2048 * vecVelDir, -extents, extents );
int nCount = UTIL_EntitiesAlongRay( list, 1024, ray, FL_NPC | FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
if ( !IsAttractiveTarget( list[i] ) )
continue;
VectorSubtract( list[i]->WorldSpaceCenter(), vecStartPoint, vecDelta );
distance = VectorNormalize( vecDelta );
flDot = DotProduct( vecDelta, vecVelDir );
if ( flDot > flMaxDot )
{
if ( distance < flBestDist )
{
pBestTarget = list[i];
flBestDist = distance;
}
}
}
}
if ( pBestTarget )
{
Vector vecDelta;
VectorSubtract( pBestTarget->WorldSpaceCenter(), vecStartPoint, vecDelta );
VectorNormalize( vecDelta );
vecDelta *= GetSpeed();
PhysCallbackSetVelocity( pEvent->pObjects[index], vecDelta );
}
}
//-----------------------------------------------------------------------------
// Bounce inside the spawner:
//-----------------------------------------------------------------------------
void CPropCombineBall::BounceInSpawner( float flSpeed, int index, gamevcollisionevent_t *pEvent )
{
GetSpawner()->RegisterReflection( this, m_bForward );
m_bForward = !m_bForward;
Vector vecTarget;
GetSpawner()->GetTargetEndpoint( m_bForward, &vecTarget );
Vector vecVelocity;
VectorSubtract( vecTarget, GetAbsOrigin(), vecVelocity );
VectorNormalize( vecVelocity );
vecVelocity *= flSpeed;
PhysCallbackSetVelocity( pEvent->pObjects[index], vecVelocity );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CPropCombineBall::IsHittableEntity( CBaseEntity *pHitEntity )
{
if ( pHitEntity->IsWorld() )
return false;
if ( pHitEntity->GetMoveType() == MOVETYPE_PUSH )
{
if( pHitEntity->GetOwnerEntity() && FClassnameIs(pHitEntity->GetOwnerEntity(), "npc_strider") )
{
// The Strider's Bone Followers are MOVETYPE_PUSH, and we want the combine ball to hit these.
return true;
}
// If the entity we hit can take damage, we're good
if ( pHitEntity->m_takedamage == DAMAGE_YES )
return true;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
Vector preVelocity = pEvent->preVelocity[index];
float flSpeed = VectorNormalize( preVelocity );
if ( m_nMaxBounces == -1 )
{
const surfacedata_t *pHit = physprops->GetSurfaceData( pEvent->surfaceProps[!index] );
if( pHit->game.material != CHAR_TEX_FLESH || !hl2_episodic.GetBool() )
{
CBaseEntity *pHitEntity = pEvent->pEntities[!index];
if ( pHitEntity && IsHittableEntity( pHitEntity ) )
{
OnHitEntity( pHitEntity, flSpeed, index, pEvent );
}
// Remove self without affecting the object that was hit. (Unless it was flesh)
NotifySpawnerOfRemoval();
PhysCallbackRemove( this->NetworkProp() );
// disable dissolve damage so we don't kill off the player when he's the one we hit
PhysClearGameFlags( VPhysicsGetObject(), FVPHYSICS_DMG_DISSOLVE );
return;
}
}
// Prevents impact sounds, effects, etc. when it's in the field
if ( !IsInField() )
{
BaseClass::VPhysicsCollision( index, pEvent );
}
if ( m_nState == STATE_HOLDING )
return;
// If we've collided going faster than our desired, then up our desired
if ( flSpeed > GetSpeed() )
{
SetSpeed( flSpeed );
}
// Make sure we don't slow down
Vector vecFinalVelocity = pEvent->postVelocity[index];
VectorNormalize( vecFinalVelocity );
vecFinalVelocity *= GetSpeed();
PhysCallbackSetVelocity( pEvent->pObjects[index], vecFinalVelocity );
CBaseEntity *pHitEntity = pEvent->pEntities[!index];
if ( pHitEntity && IsHittableEntity( pHitEntity ) )
{
OnHitEntity( pHitEntity, flSpeed, index, pEvent );
return;
}
if ( IsInField() )
{
if ( HasSpawnFlags( SF_COMBINE_BALL_BOUNCING_IN_SPAWNER ) && GetSpawner() )
{
BounceInSpawner( GetSpeed(), index, pEvent );
return;
}
PhysCallbackSetVelocity( pEvent->pObjects[index], vec3_origin );
// Delay the fade out so that we don't change our
// collision rules inside a vphysics callback.
variant_t emptyVariant;
g_EventQueue.AddEvent( this, "FadeAndRespawn", 0.01, NULL, NULL );
return;
}
if ( IsBeingCaptured() )
return;
// Do that crazy impact effect!
DoImpactEffect( preVelocity, index, pEvent );
// Only do the bounce so often
if ( gpGlobals->curtime - m_flLastBounceTime < 0.25f )
return;
// Save off our last bounce time
m_flLastBounceTime = gpGlobals->curtime;
// Reset the sound timer
SetContextThink( &CPropCombineBall::WhizSoundThink, gpGlobals->curtime + 0.01, s_pWhizThinkContext );
// Deflect towards nearby enemies
DeflectTowardEnemy( flSpeed, index, pEvent );
// Once more bounce
++m_nBounceCount;
if ( OutOfBounces() && m_bBounceDie == false )
{
StartLifetime( 0.5 );
//Hack: Stop this from being called by doing this.
m_bBounceDie = true;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropCombineBall::AnimThink( void )
{
StudioFrameAdvance();
SetContextThink( &CPropCombineBall::AnimThink, gpGlobals->curtime + 0.1f, s_pAnimThinkContext );
}
//-----------------------------------------------------------------------------
//
// Implementation of CPropCombineBall
//
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( func_combine_ball_spawner, CFuncCombineBallSpawner );
//-----------------------------------------------------------------------------
// Save/load:
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CFuncCombineBallSpawner )
DEFINE_KEYFIELD( m_nBallCount, FIELD_INTEGER, "ballcount" ),
DEFINE_KEYFIELD( m_flMinSpeed, FIELD_FLOAT, "minspeed" ),
DEFINE_KEYFIELD( m_flMaxSpeed, FIELD_FLOAT, "maxspeed" ),
DEFINE_KEYFIELD( m_flBallRadius, FIELD_FLOAT, "ballradius" ),
DEFINE_KEYFIELD( m_flBallRespawnTime, FIELD_FLOAT, "ballrespawntime" ),
DEFINE_FIELD( m_flRadius, FIELD_FLOAT ),
DEFINE_FIELD( m_nBallsRemainingInField, FIELD_INTEGER ),
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_UTLVECTOR( m_BallRespawnTime, FIELD_TIME ),
DEFINE_FIELD( m_flDisableTime, FIELD_TIME ),
DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
DEFINE_OUTPUT( m_OnBallGrabbed, "OnBallGrabbed" ),
DEFINE_OUTPUT( m_OnBallReinserted, "OnBallReinserted" ),
DEFINE_OUTPUT( m_OnBallHitTopSide, "OnBallHitTopSide" ),
DEFINE_OUTPUT( m_OnBallHitBottomSide, "OnBallHitBottomSide" ),
DEFINE_OUTPUT( m_OnLastBallGrabbed, "OnLastBallGrabbed" ),
DEFINE_OUTPUT( m_OnFirstBallReinserted, "OnFirstBallReinserted" ),
DEFINE_THINKFUNC( BallThink ),
DEFINE_ENTITYFUNC( GrabBallTouch ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CFuncCombineBallSpawner::CFuncCombineBallSpawner()
{
m_flBallRespawnTime = 0.0f;
m_flBallRadius = 20.0f;
m_flDisableTime = 0.0f;
m_bShooter = false;
}
//-----------------------------------------------------------------------------
// Spawn a ball
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::SpawnBall()
{
CPropCombineBall *pBall = static_cast<CPropCombineBall*>( CreateEntityByName( "prop_combine_ball" ) );
float flRadius = m_flBallRadius;
pBall->SetRadius( flRadius );
Vector vecAbsOrigin;
ChoosePointInBox( &vecAbsOrigin );
Vector zaxis;
MatrixGetColumn( EntityToWorldTransform(), 2, zaxis );
VectorMA( vecAbsOrigin, flRadius, zaxis, vecAbsOrigin );
pBall->SetAbsOrigin( vecAbsOrigin );
pBall->SetSpawner( this );
float flSpeed = random->RandomFloat( m_flMinSpeed, m_flMaxSpeed );
zaxis *= flSpeed;
pBall->SetAbsVelocity( zaxis );
if ( HasSpawnFlags( SF_SPAWNER_POWER_SUPPLY ) )
{
pBall->AddSpawnFlags( SF_COMBINE_BALL_BOUNCING_IN_SPAWNER );
}
pBall->Spawn();
}
void CFuncCombineBallSpawner::Precache()
{
BaseClass::Precache();
UTIL_PrecacheOther( "prop_combine_ball" );
}
//-----------------------------------------------------------------------------
// Spawn
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::Spawn()
{
BaseClass::Spawn();
Precache();
AddEffects( EF_NODRAW );
SetModel( STRING( GetModelName() ) );
SetSolid( SOLID_BSP );
AddSolidFlags( FSOLID_NOT_SOLID );
m_nBallsRemainingInField = m_nBallCount;
float flWidth = CollisionProp()->OBBSize().x;
float flHeight = CollisionProp()->OBBSize().y;
m_flRadius = MIN( flWidth, flHeight ) * 0.5f;
if ( m_flRadius <= 0.0f && m_bShooter == false )
{
Warning("Zero dimension func_combine_ball_spawner! Removing...\n");
UTIL_Remove( this );
return;
}
// Compute a respawn time
float flDeltaT = 1.0f;
if ( !( m_flMinSpeed == 0 && m_flMaxSpeed == 0 ) )
{
flDeltaT = (CollisionProp()->OBBSize().z - 2 * m_flBallRadius) / ((m_flMinSpeed + m_flMaxSpeed) * 0.5f);
flDeltaT /= m_nBallCount;
}
m_BallRespawnTime.EnsureCapacity( m_nBallCount );
for ( int i = 0; i < m_nBallCount; ++i )
{
RespawnBall( (float)i * flDeltaT );
}
m_bEnabled = true;
if ( HasSpawnFlags( SF_SPAWNER_START_DISABLED ) )
{
inputdata_t inputData;
InputDisable( inputData );
}
else
{
SetThink( &CFuncCombineBallSpawner::BallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
}
//-----------------------------------------------------------------------------
// Enable/disable
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::InputEnable( inputdata_t &inputdata )
{
if ( m_bEnabled )
return;
m_bEnabled = true;
m_flDisableTime = 0.0f;
for ( int i = m_BallRespawnTime.Count(); --i >= 0; )
{
m_BallRespawnTime[i] += gpGlobals->curtime;
}
SetThink( &CFuncCombineBallSpawner::BallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CFuncCombineBallSpawner::InputDisable( inputdata_t &inputdata )
{
if ( !m_bEnabled )
return;
m_flDisableTime = gpGlobals->curtime;
m_bEnabled = false;
for ( int i = m_BallRespawnTime.Count(); --i >= 0; )
{
m_BallRespawnTime[i] -= gpGlobals->curtime;
}
SetThink( NULL );
}
//-----------------------------------------------------------------------------
// Choose a random point inside the cylinder
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::ChoosePointInBox( Vector *pVecPoint )
{
float flXBoundary = ( CollisionProp()->OBBSize().x != 0 ) ? m_flBallRadius / CollisionProp()->OBBSize().x : 0.0f;
float flYBoundary = ( CollisionProp()->OBBSize().y != 0 ) ? m_flBallRadius / CollisionProp()->OBBSize().y : 0.0f;
if ( flXBoundary > 0.5f )
{
flXBoundary = 0.5f;
}
if ( flYBoundary > 0.5f )
{
flYBoundary = 0.5f;
}
CollisionProp()->RandomPointInBounds(
Vector( flXBoundary, flYBoundary, 0.0f ), Vector( 1.0f - flXBoundary, 1.0f - flYBoundary, 0.0f ), pVecPoint );
}
//-----------------------------------------------------------------------------
// Choose a random point inside the cylinder
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::ChoosePointInCylinder( Vector *pVecPoint )
{
float flXRange = m_flRadius / CollisionProp()->OBBSize().x;
float flYRange = m_flRadius / CollisionProp()->OBBSize().y;
Vector vecEndPoint1, vecEndPoint2;
CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 0.0f ), &vecEndPoint1 );
CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 1.0f ), &vecEndPoint2 );
// Choose a point inside the cylinder
float flDistSq;
do
{
CollisionProp()->RandomPointInBounds(
Vector( 0.5f - flXRange, 0.5f - flYRange, 0.0f ),
Vector( 0.5f + flXRange, 0.5f + flYRange, 0.0f ),
pVecPoint );
flDistSq = CalcDistanceSqrToLine( *pVecPoint, vecEndPoint1, vecEndPoint2 );
} while ( flDistSq > m_flRadius * m_flRadius );
}
//-----------------------------------------------------------------------------
// Register that a reflection occurred
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::RegisterReflection( CPropCombineBall *pBall, bool bForward )
{
if ( bForward )
{
m_OnBallHitTopSide.FireOutput( pBall, this );
}
else
{
m_OnBallHitBottomSide.FireOutput( pBall, this );
}
}
//-----------------------------------------------------------------------------
// Choose a random point on the
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::GetTargetEndpoint( bool bForward, Vector *pVecEndPoint )
{
float flZValue = bForward ? 1.0f : 0.0f;
CollisionProp()->RandomPointInBounds(
Vector( 0.0f, 0.0f, flZValue ), Vector( 1.0f, 1.0f, flZValue ), pVecEndPoint );
}
//-----------------------------------------------------------------------------
// Fire ball grabbed output
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::BallGrabbed( CBaseEntity *pCombineBall )
{
m_OnBallGrabbed.FireOutput( pCombineBall, this );
--m_nBallsRemainingInField;
if ( m_nBallsRemainingInField == 0 )
{
m_OnLastBallGrabbed.FireOutput( pCombineBall, this );
}
// Wait for another ball to touch this to re-power it up.
if ( HasSpawnFlags( SF_SPAWNER_POWER_SUPPLY ) )
{
AddSolidFlags( FSOLID_TRIGGER );
SetTouch( &CFuncCombineBallSpawner::GrabBallTouch );
}
// Stop the ball thinking in case it was in the middle of being captured (which could re-add incorrectly)
if ( pCombineBall != NULL )
{
pCombineBall->SetContextThink( NULL, gpGlobals->curtime, s_pCaptureContext );
}
}
//-----------------------------------------------------------------------------
// Fire ball grabbed output
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::GrabBallTouch( CBaseEntity *pOther )
{
// Safety net for two balls hitting this at once
if ( m_nBallsRemainingInField >= m_nBallCount )
return;
if ( pOther->GetCollisionGroup() != HL2COLLISION_GROUP_COMBINE_BALL )
return;
CPropCombineBall *pBall = dynamic_cast<CPropCombineBall*>( pOther );
Assert( pBall );
// Don't grab AR2 alt-fire
if ( pBall->WasWeaponLaunched() || !pBall->VPhysicsGetObject() )
return;
// Don't grab balls that are already in the field..
if ( pBall->IsInField() )
return;
// Don't grab fading out balls...
if ( !pBall->IsSolid() )
return;
// Don't capture balls that were very recently in the field (breaks punting)
if ( gpGlobals->curtime - pBall->LastCaptureTime() < 0.5f )
return;
// Now we're bouncing in this spawner
pBall->AddSpawnFlags( SF_COMBINE_BALL_BOUNCING_IN_SPAWNER );
// Tell the respawner we're no longer its ball
pBall->NotifySpawnerOfRemoval();
pBall->SetOwnerEntity( NULL );
pBall->SetSpawner( this );
pBall->CaptureBySpawner();
++m_nBallsRemainingInField;
if ( m_nBallsRemainingInField >= m_nBallCount )
{
RemoveSolidFlags( FSOLID_TRIGGER );
SetTouch( NULL );
}
m_OnBallReinserted.FireOutput( pBall, this );
if ( m_nBallsRemainingInField == 1 )
{
m_OnFirstBallReinserted.FireOutput( pBall, this );
}
}
//-----------------------------------------------------------------------------
// Get a speed for the ball to insert
//-----------------------------------------------------------------------------
float CFuncCombineBallSpawner::GetBallSpeed( ) const
{
return random->RandomFloat( m_flMinSpeed, m_flMaxSpeed );
}
//-----------------------------------------------------------------------------
// Balls call this when they've been removed from the spawner
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::RespawnBall( float flRespawnTime )
{
// Insert the time in sorted order,
// which by definition means to always insert at the start
m_BallRespawnTime.AddToTail( gpGlobals->curtime + flRespawnTime - m_flDisableTime );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::RespawnBallPostExplosion( void )
{
if ( m_flBallRespawnTime < 0 )
return;
if ( m_flBallRespawnTime == 0.0f )
{
m_BallRespawnTime.AddToTail( gpGlobals->curtime + 4.0f - m_flDisableTime );
}
else
{
m_BallRespawnTime.AddToTail( gpGlobals->curtime + m_flBallRespawnTime - m_flDisableTime );
}
}
//-----------------------------------------------------------------------------
// Ball think
//-----------------------------------------------------------------------------
void CFuncCombineBallSpawner::BallThink()
{
for ( int i = m_BallRespawnTime.Count(); --i >= 0; )
{
if ( m_BallRespawnTime[i] < gpGlobals->curtime )
{
SpawnBall();
m_BallRespawnTime.FastRemove( i );
}
}
// There are no more to respawn
SetNextThink( gpGlobals->curtime + 0.1f );
}
BEGIN_DATADESC( CPointCombineBallLauncher )
DEFINE_KEYFIELD( m_flConeDegrees, FIELD_FLOAT, "launchconenoise" ),
DEFINE_KEYFIELD( m_iszBullseyeName, FIELD_STRING, "bullseyename" ),
DEFINE_KEYFIELD( m_iBounces, FIELD_INTEGER, "maxballbounces" ),
DEFINE_INPUTFUNC( FIELD_VOID, "LaunchBall", InputLaunchBall ),
END_DATADESC()
#define SF_COMBINE_BALL_LAUNCHER_ATTACH_BULLSEYE 0x00000001
#define SF_COMBINE_BALL_LAUNCHER_COLLIDE_PLAYER 0x00000002
LINK_ENTITY_TO_CLASS( point_combine_ball_launcher, CPointCombineBallLauncher );
CPointCombineBallLauncher::CPointCombineBallLauncher()
{
m_bShooter = true;
m_flConeDegrees = 0.0f;
m_iBounces = 0;
}
void CPointCombineBallLauncher::Spawn( void )
{
m_bShooter = true;
BaseClass::Spawn();
}
void CPointCombineBallLauncher::InputLaunchBall ( inputdata_t &inputdata )
{
SpawnBall();
}
//-----------------------------------------------------------------------------
// Spawn a ball
//-----------------------------------------------------------------------------
void CPointCombineBallLauncher::SpawnBall()
{
CPropCombineBall *pBall = static_cast<CPropCombineBall*>( CreateEntityByName( "prop_combine_ball" ) );
if ( pBall == NULL )
return;
float flRadius = m_flBallRadius;
pBall->SetRadius( flRadius );
Vector vecAbsOrigin = GetAbsOrigin();
Vector zaxis;
pBall->SetAbsOrigin( vecAbsOrigin );
pBall->SetSpawner( this );
float flSpeed = random->RandomFloat( m_flMinSpeed, m_flMaxSpeed );
Vector vDirection;
QAngle qAngle = GetAbsAngles();
qAngle = qAngle + QAngle ( random->RandomFloat( -m_flConeDegrees, m_flConeDegrees ), random->RandomFloat( -m_flConeDegrees, m_flConeDegrees ), 0 );
AngleVectors( qAngle, &vDirection, NULL, NULL );
vDirection *= flSpeed;
pBall->SetAbsVelocity( vDirection );
DispatchSpawn(pBall);
pBall->Activate();
pBall->SetState( CPropCombineBall::STATE_LAUNCHED );
pBall->SetMaxBounces( m_iBounces );
if ( HasSpawnFlags( SF_COMBINE_BALL_LAUNCHER_COLLIDE_PLAYER ) )
{
pBall->SetCollisionGroup( HL2COLLISION_GROUP_COMBINE_BALL_NPC );
}
if( GetSpawnFlags() & SF_COMBINE_BALL_LAUNCHER_ATTACH_BULLSEYE )
{
CNPC_Bullseye *pBullseye = static_cast<CNPC_Bullseye*>( CreateEntityByName( "npc_bullseye" ) );
if( pBullseye )
{
pBullseye->SetAbsOrigin( pBall->GetAbsOrigin() );
pBullseye->SetAbsAngles( QAngle( 0, 0, 0 ) );
pBullseye->KeyValue( "solid", "6" );
pBullseye->KeyValue( "targetname", STRING(m_iszBullseyeName) );
pBullseye->Spawn();
DispatchSpawn(pBullseye);
pBullseye->Activate();
pBullseye->SetParent(pBall);
pBullseye->SetHealth(10);
}
}
}
// ###################################################################
// > FilterClass
// ###################################################################
class CFilterCombineBall : public CBaseFilter
{
DECLARE_CLASS( CFilterCombineBall, CBaseFilter );
DECLARE_DATADESC();
public:
int m_iBallType;
bool PassesFilterImpl( CBaseEntity *pCaller, CBaseEntity *pEntity )
{
CPropCombineBall *pBall = dynamic_cast<CPropCombineBall*>(pEntity );
if ( pBall )
{
//Playtest HACK: If we have an NPC owner then we were shot from an AR2.
if ( pBall->GetOwnerEntity() && pBall->GetOwnerEntity()->IsNPC() )
return false;
return pBall->GetState() == m_iBallType;
}
return false;
}
};
LINK_ENTITY_TO_CLASS( filter_combineball_type, CFilterCombineBall );
BEGIN_DATADESC( CFilterCombineBall )
// Keyfields
DEFINE_KEYFIELD( m_iBallType, FIELD_INTEGER, "balltype" ),
END_DATADESC()