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.
257 Commits
25 Branches
6 Tags
221 MiB
Tree: 3b475331f2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3b475331f2'
${ noResults }
source-engine/game/shared/hl2mp/weapon_physcannon.cpp

3686 lines
100 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Physics cannon
//
//=============================================================================//
#include "cbase.h"
#ifdef CLIENT_DLL
#include "c_hl2mp_player.h"
#include "vcollide_parse.h"
#include "engine/ivdebugoverlay.h"
#include "iviewrender_beams.h"
#include "beamdraw.h"
#include "c_te_effect_dispatch.h"
#include "model_types.h"
#include "clienteffectprecachesystem.h"
#include "fx_interpvalue.h"
#else
#include "hl2mp_player.h"
#include "soundent.h"
#include "ndebugoverlay.h"
#include "ai_basenpc.h"
#include "player_pickup.h"
#include "physics_prop_ragdoll.h"
#include "globalstate.h"
#include "props.h"
#include "te_effect_dispatch.h"
#include "util.h"
#endif
#include "gamerules.h"
#include "soundenvelope.h"
#include "engine/IEngineSound.h"
#include "physics.h"
#include "in_buttons.h"
#include "IEffects.h"
#include "shake.h"
#include "beam_shared.h"
#include "Sprite.h"
#include "weapon_physcannon.h"
#include "physics_saverestore.h"
#include "movevars_shared.h"
#include "weapon_hl2mpbasehlmpcombatweapon.h"
#include "vphysics/friction.h"
#include "debugoverlay_shared.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define SPRITE_SCALE 128.0f
static const char *s_pWaitForUpgradeContext = "WaitForUpgrade";
ConVar g_debug_physcannon( "g_debug_physcannon", "0", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_minforce( "physcannon_minforce", "700", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_maxforce( "physcannon_maxforce", "1500", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_maxmass( "physcannon_maxmass", "250", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_tracelength( "physcannon_tracelength", "250", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_chargetime("physcannon_chargetime", "2", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_pullforce( "physcannon_pullforce", "4000", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_cone( "physcannon_cone", "0.97", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar physcannon_ball_cone( "physcannon_ball_cone", "0.997", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar player_throwforce( "player_throwforce", "1000", FCVAR_REPLICATED | FCVAR_CHEAT );
#ifndef CLIENT_DLL
extern ConVar hl2_normspeed;
extern ConVar hl2_walkspeed;
#endif
#define PHYSCANNON_BEAM_SPRITE "sprites/orangelight1.vmt"
#define PHYSCANNON_BEAM_SPRITE_NOZ "sprites/orangelight1_noz.vmt"
#define PHYSCANNON_GLOW_SPRITE "sprites/glow04_noz"
#define PHYSCANNON_ENDCAP_SPRITE "sprites/orangeflare1"
#define PHYSCANNON_CENTER_GLOW "sprites/orangecore1"
#define PHYSCANNON_BLAST_SPRITE "sprites/orangecore2"
#ifdef CLIENT_DLL
//Precahce the effects
CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectPhysCannon )
CLIENTEFFECT_MATERIAL( "sprites/orangelight1" )
CLIENTEFFECT_MATERIAL( "sprites/orangelight1_noz" )
CLIENTEFFECT_MATERIAL( PHYSCANNON_GLOW_SPRITE )
CLIENTEFFECT_MATERIAL( PHYSCANNON_ENDCAP_SPRITE )
CLIENTEFFECT_MATERIAL( PHYSCANNON_CENTER_GLOW )
CLIENTEFFECT_MATERIAL( PHYSCANNON_BLAST_SPRITE )
CLIENTEFFECT_REGISTER_END()
#endif // CLIENT_DLL
#ifndef CLIENT_DLL
void PhysCannonBeginUpgrade( CBaseAnimating *pAnim )
{
}
bool PlayerHasMegaPhysCannon( void )
{
return false;
}
bool PhysCannonAccountableForObject( CBaseCombatWeapon *pPhysCannon, CBaseEntity *pObject )
{
// BRJ: FIXME! This can't be implemented trivially, so I'm leaving it to Steve or Adrian
Assert( 0 );
return false;
}
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// this will hit skip the pass entity, but not anything it owns
// (lets player grab own grenades)
class CTraceFilterNoOwnerTest : public CTraceFilterSimple
{
public:
DECLARE_CLASS( CTraceFilterNoOwnerTest, CTraceFilterSimple );
CTraceFilterNoOwnerTest( const IHandleEntity *passentity, int collisionGroup )
: CTraceFilterSimple( NULL, collisionGroup ), m_pPassNotOwner(passentity)
{
}
virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( pHandleEntity != m_pPassNotOwner )
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
return false;
}
protected:
const IHandleEntity *m_pPassNotOwner;
};
static void MatrixOrthogonalize( matrix3x4_t &matrix, int column )
{
Vector columns[3];
int i;
for ( i = 0; i < 3; i++ )
{
MatrixGetColumn( matrix, i, columns[i] );
}
int index0 = column;
int index1 = (column+1)%3;
int index2 = (column+2)%3;
columns[index2] = CrossProduct( columns[index0], columns[index1] );
columns[index1] = CrossProduct( columns[index2], columns[index0] );
VectorNormalize( columns[index2] );
VectorNormalize( columns[index1] );
MatrixSetColumn( columns[index1], index1, matrix );
MatrixSetColumn( columns[index2], index2, matrix );
}
#define SIGN(x) ( (x) < 0 ? -1 : 1 )
static QAngle AlignAngles( const QAngle &angles, float cosineAlignAngle )
{
matrix3x4_t alignMatrix;
AngleMatrix( angles, alignMatrix );
// NOTE: Must align z first
for ( int j = 3; --j >= 0; )
{
Vector vec;
MatrixGetColumn( alignMatrix, j, vec );
for ( int i = 0; i < 3; i++ )
{
if ( fabs(vec[i]) > cosineAlignAngle )
{
vec[i] = SIGN(vec[i]);
vec[(i+1)%3] = 0;
vec[(i+2)%3] = 0;
MatrixSetColumn( vec, j, alignMatrix );
MatrixOrthogonalize( alignMatrix, j );
break;
}
}
}
QAngle out;
MatrixAngles( alignMatrix, out );
return out;
}
static void TraceCollideAgainstBBox( const CPhysCollide *pCollide, const Vector &start, const Vector &end, const QAngle &angles, const Vector &boxOrigin, const Vector &mins, const Vector &maxs, trace_t *ptr )
{
physcollision->TraceBox( boxOrigin, boxOrigin + (start-end), mins, maxs, pCollide, start, angles, ptr );
if ( ptr->DidHit() )
{
ptr->endpos = start * (1-ptr->fraction) + end * ptr->fraction;
ptr->startpos = start;
ptr->plane.dist = -ptr->plane.dist;
ptr->plane.normal *= -1;
}
}
//-----------------------------------------------------------------------------
// Purpose: Computes a local matrix for the player clamped to valid carry ranges
//-----------------------------------------------------------------------------
// when looking level, hold bottom of object 8 inches below eye level
#define PLAYER_HOLD_LEVEL_EYES -8
// when looking down, hold bottom of object 0 inches from feet
#define PLAYER_HOLD_DOWN_FEET 2
// when looking up, hold bottom of object 24 inches above eye level
#define PLAYER_HOLD_UP_EYES 24
// use a +/-30 degree range for the entire range of motion of pitch
#define PLAYER_LOOK_PITCH_RANGE 30
// player can reach down 2ft below his feet (otherwise he'll hold the object above the bottom)
#define PLAYER_REACH_DOWN_DISTANCE 24
static void ComputePlayerMatrix( CBasePlayer *pPlayer, matrix3x4_t &out )
{
if ( !pPlayer )
return;
QAngle angles = pPlayer->EyeAngles();
Vector origin = pPlayer->EyePosition();
// 0-360 / -180-180
//angles.x = init ? 0 : AngleDistance( angles.x, 0 );
//angles.x = clamp( angles.x, -PLAYER_LOOK_PITCH_RANGE, PLAYER_LOOK_PITCH_RANGE );
angles.x = 0;
float feet = pPlayer->GetAbsOrigin().z + pPlayer->WorldAlignMins().z;
float eyes = origin.z;
float zoffset = 0;
// moving up (negative pitch is up)
if ( angles.x < 0 )
{
zoffset = RemapVal( angles.x, 0, -PLAYER_LOOK_PITCH_RANGE, PLAYER_HOLD_LEVEL_EYES, PLAYER_HOLD_UP_EYES );
}
else
{
zoffset = RemapVal( angles.x, 0, PLAYER_LOOK_PITCH_RANGE, PLAYER_HOLD_LEVEL_EYES, PLAYER_HOLD_DOWN_FEET + (feet - eyes) );
}
origin.z += zoffset;
angles.x = 0;
AngleMatrix( angles, origin, out );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
// derive from this so we can add save/load data to it
struct game_shadowcontrol_params_t : public hlshadowcontrol_params_t
{
DECLARE_SIMPLE_DATADESC();
};
BEGIN_SIMPLE_DATADESC( game_shadowcontrol_params_t )
DEFINE_FIELD( targetPosition, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( targetRotation, FIELD_VECTOR ),
DEFINE_FIELD( maxAngular, FIELD_FLOAT ),
DEFINE_FIELD( maxDampAngular, FIELD_FLOAT ),
DEFINE_FIELD( maxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( maxDampSpeed, FIELD_FLOAT ),
DEFINE_FIELD( dampFactor, FIELD_FLOAT ),
DEFINE_FIELD( teleportDistance, FIELD_FLOAT ),
END_DATADESC()
//-----------------------------------------------------------------------------
class CGrabController : public IMotionEvent
{
public:
CGrabController( void );
~CGrabController( void );
void AttachEntity( CBasePlayer *pPlayer, CBaseEntity *pEntity, IPhysicsObject *pPhys, bool bIsMegaPhysCannon, const Vector &vGrabPosition, bool bUseGrabPosition );
void DetachEntity( bool bClearVelocity );
void OnRestore();
bool UpdateObject( CBasePlayer *pPlayer, float flError );
void SetTargetPosition( const Vector &target, const QAngle &targetOrientation );
float ComputeError();
float GetLoadWeight( void ) const { return m_flLoadWeight; }
void SetAngleAlignment( float alignAngleCosine ) { m_angleAlignment = alignAngleCosine; }
void SetIgnorePitch( bool bIgnore ) { m_bIgnoreRelativePitch = bIgnore; }
QAngle TransformAnglesToPlayerSpace( const QAngle &anglesIn, CBasePlayer *pPlayer );
QAngle TransformAnglesFromPlayerSpace( const QAngle &anglesIn, CBasePlayer *pPlayer );
CBaseEntity *GetAttached() { return (CBaseEntity *)m_attachedEntity; }
IMotionEvent::simresult_e Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular );
float GetSavedMass( IPhysicsObject *pObject );
QAngle m_attachedAnglesPlayerSpace;
Vector m_attachedPositionObjectSpace;
private:
// Compute the max speed for an attached object
void ComputeMaxSpeed( CBaseEntity *pEntity, IPhysicsObject *pPhysics );
game_shadowcontrol_params_t m_shadow;
float m_timeToArrive;
float m_errorTime;
float m_error;
float m_contactAmount;
float m_angleAlignment;
bool m_bCarriedEntityBlocksLOS;
bool m_bIgnoreRelativePitch;
float m_flLoadWeight;
float m_savedRotDamping[VPHYSICS_MAX_OBJECT_LIST_COUNT];
float m_savedMass[VPHYSICS_MAX_OBJECT_LIST_COUNT];
EHANDLE m_attachedEntity;
QAngle m_vecPreferredCarryAngles;
bool m_bHasPreferredCarryAngles;
IPhysicsMotionController *m_controller;
int m_frameCount;
friend class CWeaponPhysCannon;
};
const float DEFAULT_MAX_ANGULAR = 360.0f * 10.0f;
const float REDUCED_CARRY_MASS = 1.0f;
CGrabController::CGrabController( void )
{
m_shadow.dampFactor = 1.0;
m_shadow.teleportDistance = 0;
m_errorTime = 0;
m_error = 0;
// make this controller really stiff!
m_shadow.maxSpeed = 1000;
m_shadow.maxAngular = DEFAULT_MAX_ANGULAR;
m_shadow.maxDampSpeed = m_shadow.maxSpeed*2;
m_shadow.maxDampAngular = m_shadow.maxAngular;
m_attachedEntity = NULL;
m_vecPreferredCarryAngles = vec3_angle;
m_bHasPreferredCarryAngles = false;
}
CGrabController::~CGrabController( void )
{
DetachEntity( false );
}
void CGrabController::OnRestore()
{
if ( m_controller )
{
m_controller->SetEventHandler( this );
}
}
void CGrabController::SetTargetPosition( const Vector &target, const QAngle &targetOrientation )
{
m_shadow.targetPosition = target;
m_shadow.targetRotation = targetOrientation;
m_timeToArrive = gpGlobals->frametime;
CBaseEntity *pAttached = GetAttached();
if ( pAttached )
{
IPhysicsObject *pObj = pAttached->VPhysicsGetObject();
if ( pObj != NULL )
{
pObj->Wake();
}
else
{
DetachEntity( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CGrabController::ComputeError()
{
if ( m_errorTime <= 0 )
return 0;
CBaseEntity *pAttached = GetAttached();
if ( pAttached )
{
Vector pos;
IPhysicsObject *pObj = pAttached->VPhysicsGetObject();
if ( pObj )
{
pObj->GetShadowPosition( &pos, NULL );
float error = (m_shadow.targetPosition - pos).Length();
if ( m_errorTime > 0 )
{
if ( m_errorTime > 1 )
{
m_errorTime = 1;
}
float speed = error / m_errorTime;
if ( speed > m_shadow.maxSpeed )
{
error *= 0.5;
}
m_error = (1-m_errorTime) * m_error + error * m_errorTime;
}
}
else
{
DevMsg( "Object attached to Physcannon has no physics object\n" );
DetachEntity( false );
return 9999; // force detach
}
}
if ( pAttached->IsEFlagSet( EFL_IS_BEING_LIFTED_BY_BARNACLE ) )
{
m_error *= 3.0f;
}
m_errorTime = 0;
return m_error;
}
#define MASS_SPEED_SCALE 60
#define MAX_MASS 40
void CGrabController::ComputeMaxSpeed( CBaseEntity *pEntity, IPhysicsObject *pPhysics )
{
#ifndef CLIENT_DLL
m_shadow.maxSpeed = 1000;
m_shadow.maxAngular = DEFAULT_MAX_ANGULAR;
// Compute total mass...
float flMass = PhysGetEntityMass( pEntity );
float flMaxMass = physcannon_maxmass.GetFloat();
if ( flMass <= flMaxMass )
return;
float flLerpFactor = clamp( flMass, flMaxMass, 500.0f );
flLerpFactor = SimpleSplineRemapVal( flLerpFactor, flMaxMass, 500.0f, 0.0f, 1.0f );
float invMass = pPhysics->GetInvMass();
float invInertia = pPhysics->GetInvInertia().Length();
float invMaxMass = 1.0f / MAX_MASS;
float ratio = invMaxMass / invMass;
invMass = invMaxMass;
invInertia *= ratio;
float maxSpeed = invMass * MASS_SPEED_SCALE * 200;
float maxAngular = invInertia * MASS_SPEED_SCALE * 360;
m_shadow.maxSpeed = Lerp( flLerpFactor, m_shadow.maxSpeed, maxSpeed );
m_shadow.maxAngular = Lerp( flLerpFactor, m_shadow.maxAngular, maxAngular );
#endif
}
QAngle CGrabController::TransformAnglesToPlayerSpace( const QAngle &anglesIn, CBasePlayer *pPlayer )
{
if ( m_bIgnoreRelativePitch )
{
matrix3x4_t test;
QAngle angleTest = pPlayer->EyeAngles();
angleTest.x = 0;
AngleMatrix( angleTest, test );
return TransformAnglesToLocalSpace( anglesIn, test );
}
return TransformAnglesToLocalSpace( anglesIn, pPlayer->EntityToWorldTransform() );
}
QAngle CGrabController::TransformAnglesFromPlayerSpace( const QAngle &anglesIn, CBasePlayer *pPlayer )
{
if ( m_bIgnoreRelativePitch )
{
matrix3x4_t test;
QAngle angleTest = pPlayer->EyeAngles();
angleTest.x = 0;
AngleMatrix( angleTest, test );
return TransformAnglesToWorldSpace( anglesIn, test );
}
return TransformAnglesToWorldSpace( anglesIn, pPlayer->EntityToWorldTransform() );
}
void CGrabController::AttachEntity( CBasePlayer *pPlayer, CBaseEntity *pEntity, IPhysicsObject *pPhys, bool bIsMegaPhysCannon, const Vector &vGrabPosition, bool bUseGrabPosition )
{
// play the impact sound of the object hitting the player
// used as feedback to let the player know he picked up the object
#ifndef CLIENT_DLL
PhysicsImpactSound( pPlayer, pPhys, CHAN_STATIC, pPhys->GetMaterialIndex(), pPlayer->VPhysicsGetObject()->GetMaterialIndex(), 1.0, 64 );
#endif
Vector position;
QAngle angles;
pPhys->GetPosition( &position, &angles );
// If it has a preferred orientation, use that instead.
#ifndef CLIENT_DLL
Pickup_GetPreferredCarryAngles( pEntity, pPlayer, pPlayer->EntityToWorldTransform(), angles );
#endif
// ComputeMaxSpeed( pEntity, pPhys );
// Carried entities can never block LOS
m_bCarriedEntityBlocksLOS = pEntity->BlocksLOS();
pEntity->SetBlocksLOS( false );
m_controller = physenv->CreateMotionController( this );
m_controller->AttachObject( pPhys, true );
// Don't do this, it's causing trouble with constraint solvers.
//m_controller->SetPriority( IPhysicsMotionController::HIGH_PRIORITY );
pPhys->Wake();
PhysSetGameFlags( pPhys, FVPHYSICS_PLAYER_HELD );
SetTargetPosition( position, angles );
m_attachedEntity = pEntity;
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
m_flLoadWeight = 0;
float damping = 10;
float flFactor = count / 7.5f;
if ( flFactor < 1.0f )
{
flFactor = 1.0f;
}
for ( int i = 0; i < count; i++ )
{
float mass = pList[i]->GetMass();
pList[i]->GetDamping( NULL, &m_savedRotDamping[i] );
m_flLoadWeight += mass;
m_savedMass[i] = mass;
// reduce the mass to prevent the player from adding crazy amounts of energy to the system
pList[i]->SetMass( REDUCED_CARRY_MASS / flFactor );
pList[i]->SetDamping( NULL, &damping );
}
// Give extra mass to the phys object we're actually picking up
pPhys->SetMass( REDUCED_CARRY_MASS );
pPhys->EnableDrag( false );
m_errorTime = -1.0f; // 1 seconds until error starts accumulating
m_error = 0;
m_contactAmount = 0;
m_attachedAnglesPlayerSpace = TransformAnglesToPlayerSpace( angles, pPlayer );
if ( m_angleAlignment != 0 )
{
m_attachedAnglesPlayerSpace = AlignAngles( m_attachedAnglesPlayerSpace, m_angleAlignment );
}
VectorITransform( pEntity->WorldSpaceCenter(), pEntity->EntityToWorldTransform(), m_attachedPositionObjectSpace );
#ifndef CLIENT_DLL
// If it's a prop, see if it has desired carry angles
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp *>(pEntity);
if ( pProp )
{
m_bHasPreferredCarryAngles = pProp->GetPropDataAngles( "preferred_carryangles", m_vecPreferredCarryAngles );
}
else
{
m_bHasPreferredCarryAngles = false;
}
#else
m_bHasPreferredCarryAngles = false;
#endif
}
static void ClampPhysicsVelocity( IPhysicsObject *pPhys, float linearLimit, float angularLimit )
{
Vector vel;
AngularImpulse angVel;
pPhys->GetVelocity( &vel, &angVel );
float speed = VectorNormalize(vel) - linearLimit;
float angSpeed = VectorNormalize(angVel) - angularLimit;
speed = speed < 0 ? 0 : -speed;
angSpeed = angSpeed < 0 ? 0 : -angSpeed;
vel *= speed;
angVel *= angSpeed;
pPhys->AddVelocity( &vel, &angVel );
}
void CGrabController::DetachEntity( bool bClearVelocity )
{
CBaseEntity *pEntity = GetAttached();
if ( pEntity )
{
// Restore the LS blocking state
pEntity->SetBlocksLOS( m_bCarriedEntityBlocksLOS );
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
IPhysicsObject *pPhys = pList[i];
if ( !pPhys )
continue;
// on the odd chance that it's gone to sleep while under anti-gravity
pPhys->EnableDrag( true );
pPhys->Wake();
pPhys->SetMass( m_savedMass[i] );
pPhys->SetDamping( NULL, &m_savedRotDamping[i] );
PhysClearGameFlags( pPhys, FVPHYSICS_PLAYER_HELD );
if ( bClearVelocity )
{
PhysForceClearVelocity( pPhys );
}
else
{
#ifndef CLIENT_DLL
ClampPhysicsVelocity( pPhys, hl2_normspeed.GetFloat() * 1.5f, 2.0f * 360.0f );
#endif
}
}
}
m_attachedEntity = NULL;
if ( physenv )
{
physenv->DestroyMotionController( m_controller );
}
m_controller = NULL;
}
static bool InContactWithHeavyObject( IPhysicsObject *pObject, float heavyMass )
{
bool contact = false;
IPhysicsFrictionSnapshot *pSnapshot = pObject->CreateFrictionSnapshot();
while ( pSnapshot->IsValid() )
{
IPhysicsObject *pOther = pSnapshot->GetObject( 1 );
if ( !pOther->IsMoveable() || pOther->GetMass() > heavyMass )
{
contact = true;
break;
}
pSnapshot->NextFrictionData();
}
pObject->DestroyFrictionSnapshot( pSnapshot );
return contact;
}
IMotionEvent::simresult_e CGrabController::Simulate( IPhysicsMotionController *pController, IPhysicsObject *pObject, float deltaTime, Vector &linear, AngularImpulse &angular )
{
game_shadowcontrol_params_t shadowParams = m_shadow;
if ( InContactWithHeavyObject( pObject, GetLoadWeight() ) )
{
m_contactAmount = Approach( 0.1f, m_contactAmount, deltaTime*2.0f );
}
else
{
m_contactAmount = Approach( 1.0f, m_contactAmount, deltaTime*2.0f );
}
shadowParams.maxAngular = m_shadow.maxAngular * m_contactAmount * m_contactAmount * m_contactAmount;
#ifndef CLIENT_DLL
m_timeToArrive = pObject->ComputeShadowControl( shadowParams, m_timeToArrive, deltaTime );
#else
m_timeToArrive = pObject->ComputeShadowControl( shadowParams, (TICK_INTERVAL*2), deltaTime );
#endif
// Slide along the current contact points to fix bouncing problems
Vector velocity;
AngularImpulse angVel;
pObject->GetVelocity( &velocity, &angVel );
PhysComputeSlideDirection( pObject, velocity, angVel, &velocity, &angVel, GetLoadWeight() );
pObject->SetVelocityInstantaneous( &velocity, NULL );
linear.Init();
angular.Init();
m_errorTime += deltaTime;
return SIM_LOCAL_ACCELERATION;
}
float CGrabController::GetSavedMass( IPhysicsObject *pObject )
{
CBaseEntity *pHeld = m_attachedEntity;
if ( pHeld )
{
if ( pObject->GetGameData() == (void*)pHeld )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pHeld->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
for ( int i = 0; i < count; i++ )
{
if ( pList[i] == pObject )
return m_savedMass[i];
}
}
}
return 0.0f;
}
//-----------------------------------------------------------------------------
// Player pickup controller
//-----------------------------------------------------------------------------
class CPlayerPickupController : public CBaseEntity
{
DECLARE_CLASS( CPlayerPickupController, CBaseEntity );
public:
void Init( CBasePlayer *pPlayer, CBaseEntity *pObject );
void Shutdown( bool bThrown = false );
bool OnControls( CBaseEntity *pControls ) { return true; }
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void OnRestore()
{
m_grabController.OnRestore();
}
void VPhysicsUpdate( IPhysicsObject *pPhysics ){}
void VPhysicsShadowUpdate( IPhysicsObject *pPhysics ) {}
bool IsHoldingEntity( CBaseEntity *pEnt );
CGrabController &GetGrabController() { return m_grabController; }
private:
CGrabController m_grabController;
CBasePlayer *m_pPlayer;
};
LINK_ENTITY_TO_CLASS( player_pickup, CPlayerPickupController );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPlayer -
// *pObject -
//-----------------------------------------------------------------------------
void CPlayerPickupController::Init( CBasePlayer *pPlayer, CBaseEntity *pObject )
{
#ifndef CLIENT_DLL
// Holster player's weapon
if ( pPlayer->GetActiveWeapon() )
{
if ( !pPlayer->GetActiveWeapon()->Holster() )
{
Shutdown();
return;
}
}
CHL2MP_Player *pOwner = (CHL2MP_Player *)ToBasePlayer( pPlayer );
if ( pOwner )
{
pOwner->EnableSprint( false );
}
// If the target is debris, convert it to non-debris
if ( pObject->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
{
// Interactive debris converts back to debris when it comes to rest
pObject->SetCollisionGroup( COLLISION_GROUP_INTERACTIVE_DEBRIS );
}
// done so I'll go across level transitions with the player
SetParent( pPlayer );
m_grabController.SetIgnorePitch( true );
m_grabController.SetAngleAlignment( DOT_30DEGREE );
m_pPlayer = pPlayer;
IPhysicsObject *pPhysics = pObject->VPhysicsGetObject();
Pickup_OnPhysGunPickup( pObject, m_pPlayer );
m_grabController.AttachEntity( pPlayer, pObject, pPhysics, false, vec3_origin, false );
m_pPlayer->m_Local.m_iHideHUD |= HIDEHUD_WEAPONSELECTION;
m_pPlayer->SetUseEntity( this );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bool -
//-----------------------------------------------------------------------------
void CPlayerPickupController::Shutdown( bool bThrown )
{
#ifndef CLIENT_DLL
CBaseEntity *pObject = m_grabController.GetAttached();
bool bClearVelocity = false;
if ( !bThrown && pObject && pObject->VPhysicsGetObject() && pObject->VPhysicsGetObject()->GetContactPoint(NULL,NULL) )
{
bClearVelocity = true;
}
m_grabController.DetachEntity( bClearVelocity );
if ( pObject != NULL )
{
Pickup_OnPhysGunDrop( pObject, m_pPlayer, bThrown ? THROWN_BY_PLAYER : DROPPED_BY_PLAYER );
}
if ( m_pPlayer )
{
CHL2MP_Player *pOwner = (CHL2MP_Player *)ToBasePlayer( m_pPlayer );
if ( pOwner )
{
pOwner->EnableSprint( true );
}
m_pPlayer->SetUseEntity( NULL );
if ( m_pPlayer->GetActiveWeapon() )
{
if ( !m_pPlayer->GetActiveWeapon()->Deploy() )
{
// We tried to restore the player's weapon, but we couldn't.
// This usually happens when they're holding an empty weapon that doesn't
// autoswitch away when out of ammo. Switch to next best weapon.
m_pPlayer->SwitchToNextBestWeapon( NULL );
}
}
m_pPlayer->m_Local.m_iHideHUD &= ~HIDEHUD_WEAPONSELECTION;
}
Remove();
#endif
}
void CPlayerPickupController::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( ToBasePlayer(pActivator) == m_pPlayer )
{
CBaseEntity *pAttached = m_grabController.GetAttached();
// UNDONE: Use vphysics stress to decide to drop objects
// UNDONE: Must fix case of forcing objects into the ground you're standing on (causes stress) before that will work
if ( !pAttached || useType == USE_OFF || (m_pPlayer->m_nButtons & IN_ATTACK2) || m_grabController.ComputeError() > 12 )
{
Shutdown();
return;
}
//Adrian: Oops, our object became motion disabled, let go!
IPhysicsObject *pPhys = pAttached->VPhysicsGetObject();
if ( pPhys && pPhys->IsMoveable() == false )
{
Shutdown();
return;
}
#if STRESS_TEST
vphysics_objectstress_t stress;
CalculateObjectStress( pPhys, pAttached, &stress );
if ( stress.exertedStress > 250 )
{
Shutdown();
return;
}
#endif
// +ATTACK will throw phys objects
if ( m_pPlayer->m_nButtons & IN_ATTACK )
{
Shutdown( true );
Vector vecLaunch;
m_pPlayer->EyeVectors( &vecLaunch );
// JAY: Scale this with mass because some small objects really go flying
float massFactor = clamp( pPhys->GetMass(), 0.5, 15 );
massFactor = RemapVal( massFactor, 0.5, 15, 0.5, 4 );
vecLaunch *= player_throwforce.GetFloat() * massFactor;
pPhys->ApplyForceCenter( vecLaunch );
AngularImpulse aVel = RandomAngularImpulse( -10, 10 ) * massFactor;
pPhys->ApplyTorqueCenter( aVel );
return;
}
if ( useType == USE_SET )
{
// update position
m_grabController.UpdateObject( m_pPlayer, 12 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEnt -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPlayerPickupController::IsHoldingEntity( CBaseEntity *pEnt )
{
return ( m_grabController.GetAttached() == pEnt );
}
void PlayerPickupObject( CBasePlayer *pPlayer, CBaseEntity *pObject )
{
#ifndef CLIENT_DLL
//Don't pick up if we don't have a phys object.
if ( pObject->VPhysicsGetObject() == NULL )
return;
CPlayerPickupController *pController = (CPlayerPickupController *)CBaseEntity::Create( "player_pickup", pObject->GetAbsOrigin(), vec3_angle, pPlayer );
if ( !pController )
return;
pController->Init( pPlayer, pObject );
#endif
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------
// CInterpolatedValue class
//----------------------------------------------------------------------------------------------------------------------------------------------------------
#ifdef CLIENT_DLL
//----------------------------------------------------------------------------------------------------------------------------------------------------------
// CPhysCannonEffect class
//----------------------------------------------------------------------------------------------------------------------------------------------------------
class CPhysCannonEffect
{
public:
CPhysCannonEffect( void ) : m_vecColor( 255, 255, 255 ), m_bVisible( true ), m_nAttachment( -1 ) {};
void SetAttachment( int attachment ) { m_nAttachment = attachment; }
int GetAttachment( void ) const { return m_nAttachment; }
void SetVisible( bool visible = true ) { m_bVisible = visible; }
int IsVisible( void ) const { return m_bVisible; }
void SetColor( const Vector &color ) { m_vecColor = color; }
const Vector &GetColor( void ) const { return m_vecColor; }
bool SetMaterial( const char *materialName )
{
m_hMaterial.Init( materialName, TEXTURE_GROUP_CLIENT_EFFECTS );
return ( m_hMaterial != NULL );
}
CMaterialReference &GetMaterial( void ) { return m_hMaterial; }
CInterpolatedValue &GetAlpha( void ) { return m_Alpha; }
CInterpolatedValue &GetScale( void ) { return m_Scale; }
private:
CInterpolatedValue m_Alpha;
CInterpolatedValue m_Scale;
Vector m_vecColor;
bool m_bVisible;
int m_nAttachment;
CMaterialReference m_hMaterial;
};
//----------------------------------------------------------------------------------------------------------------------------------------------------------
// CPhysCannonEffectBeam class
//----------------------------------------------------------------------------------------------------------------------------------------------------------
class CPhysCannonEffectBeam
{
public:
CPhysCannonEffectBeam( void ) : m_pBeam( NULL ) {};
~CPhysCannonEffectBeam( void )
{
Release();
}
void Release( void )
{
if ( m_pBeam != NULL )
{
m_pBeam->flags = 0;
m_pBeam->die = gpGlobals->curtime - 1;
m_pBeam = NULL;
}
}
void Init( int startAttachment, int endAttachment, CBaseEntity *pEntity, bool firstPerson )
{
if ( m_pBeam != NULL )
return;
BeamInfo_t beamInfo;
beamInfo.m_pStartEnt = pEntity;
beamInfo.m_nStartAttachment = startAttachment;
beamInfo.m_pEndEnt = pEntity;
beamInfo.m_nEndAttachment = endAttachment;
beamInfo.m_nType = TE_BEAMPOINTS;
beamInfo.m_vecStart = vec3_origin;
beamInfo.m_vecEnd = vec3_origin;
beamInfo.m_pszModelName = ( firstPerson ) ? PHYSCANNON_BEAM_SPRITE_NOZ : PHYSCANNON_BEAM_SPRITE;
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
if ( firstPerson )
{
beamInfo.m_flWidth = 0.0f;
beamInfo.m_flEndWidth = 4.0f;
}
else
{
beamInfo.m_flWidth = 0.5f;
beamInfo.m_flEndWidth = 2.0f;
}
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 16;
beamInfo.m_flBrightness = 255.0;
beamInfo.m_flSpeed = 150.0f;
beamInfo.m_nStartFrame = 0.0;
beamInfo.m_flFrameRate = 30.0;
beamInfo.m_flRed = 255.0;
beamInfo.m_flGreen = 255.0;
beamInfo.m_flBlue = 255.0;
beamInfo.m_nSegments = 8;
beamInfo.m_bRenderable = true;
beamInfo.m_nFlags = FBEAM_FOREVER;
m_pBeam = beams->CreateBeamEntPoint( beamInfo );
}
void SetVisible( bool state = true )
{
if ( m_pBeam == NULL )
return;
m_pBeam->brightness = ( state ) ? 255.0f : 0.0f;
}
private:
Beam_t *m_pBeam;
};
#endif
//----------------------------------------------------------------------------------------------------------------------------------------------------------
// CWeaponPhysCannon class
//----------------------------------------------------------------------------------------------------------------------------------------------------------
#ifdef CLIENT_DLL
#define CWeaponPhysCannon C_WeaponPhysCannon
#endif
class CWeaponPhysCannon : public CBaseHL2MPCombatWeapon
{
public:
DECLARE_CLASS( CWeaponPhysCannon, CBaseHL2MPCombatWeapon );
DECLARE_NETWORKCLASS();
DECLARE_PREDICTABLE();
CWeaponPhysCannon( void );
void Drop( const Vector &vecVelocity );
void Precache();
virtual void OnRestore();
virtual void StopLoopingSounds();
virtual void UpdateOnRemove(void);
void PrimaryAttack();
void SecondaryAttack();
void WeaponIdle();
void ItemPreFrame();
void ItemPostFrame();
void ForceDrop( void );
bool DropIfEntityHeld( CBaseEntity *pTarget ); // Drops its held entity if it matches the entity passed in
CGrabController &GetGrabController() { return m_grabController; }
bool CanHolster( void );
bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
bool Deploy( void );
bool HasAnyAmmo( void ) { return true; }
virtual void SetViewModel( void );
virtual const char *GetShootSound( int iIndex ) const;
#ifndef CLIENT_DLL
CNetworkQAngle ( m_attachedAnglesPlayerSpace );
#else
QAngle m_attachedAnglesPlayerSpace;
#endif
CNetworkVector ( m_attachedPositionObjectSpace );
CNetworkHandle( CBaseEntity, m_hAttachedObject );
EHANDLE m_hOldAttachedObject;
protected:
enum FindObjectResult_t
{
OBJECT_FOUND = 0,
OBJECT_NOT_FOUND,
OBJECT_BEING_DETACHED,
};
void DoEffect( int effectType, Vector *pos = NULL );
void OpenElements( void );
void CloseElements( void );
// Pickup and throw objects.
bool CanPickupObject( CBaseEntity *pTarget );
void CheckForTarget( void );
#ifndef CLIENT_DLL
bool AttachObject( CBaseEntity *pObject, const Vector &vPosition );
FindObjectResult_t FindObject( void );
CBaseEntity *FindObjectInCone( const Vector &vecOrigin, const Vector &vecDir, float flCone );
#endif // !CLIENT_DLL
void UpdateObject( void );
void DetachObject( bool playSound = true, bool wasLaunched = false );
void LaunchObject( const Vector &vecDir, float flForce );
void StartEffects( void ); // Initialize all sprites and beams
void StopEffects( bool stopSound = true ); // Hide all effects temporarily
void DestroyEffects( void ); // Destroy all sprites and beams
// Punt objects - this is pointing at an object in the world and applying a force to it.
void PuntNonVPhysics( CBaseEntity *pEntity, const Vector &forward, trace_t &tr );
void PuntVPhysics( CBaseEntity *pEntity, const Vector &forward, trace_t &tr );
// Velocity-based throw common to punt and launch code.
void ApplyVelocityBasedForce( CBaseEntity *pEntity, const Vector &forward );
// Physgun effects
void DoEffectClosed( void );
void DoEffectReady( void );
void DoEffectHolding( void );
void DoEffectLaunch( Vector *pos );
void DoEffectNone( void );
void DoEffectIdle( void );
// Trace length
float TraceLength();
// Sprite scale factor
float SpriteScaleFactor();
float GetLoadPercentage();
CSoundPatch *GetMotorSound( void );
void DryFire( void );
void PrimaryFireEffect( void );
#ifndef CLIENT_DLL
// What happens when the physgun picks up something
void Physgun_OnPhysGunPickup( CBaseEntity *pEntity, CBasePlayer *pOwner, PhysGunPickup_t reason );
#endif // !CLIENT_DLL
#ifdef CLIENT_DLL
enum EffectType_t
{
PHYSCANNON_CORE = 0,
PHYSCANNON_BLAST,
PHYSCANNON_GLOW1, // Must be in order!
PHYSCANNON_GLOW2,
PHYSCANNON_GLOW3,
PHYSCANNON_GLOW4,
PHYSCANNON_GLOW5,
PHYSCANNON_GLOW6,
PHYSCANNON_ENDCAP1, // Must be in order!
PHYSCANNON_ENDCAP2,
PHYSCANNON_ENDCAP3, // Only used in third-person!
NUM_PHYSCANNON_PARAMETERS // Must be last!
};
#define NUM_GLOW_SPRITES ((CWeaponPhysCannon::PHYSCANNON_GLOW6-CWeaponPhysCannon::PHYSCANNON_GLOW1)+1)
#define NUM_ENDCAP_SPRITES ((CWeaponPhysCannon::PHYSCANNON_ENDCAP3-CWeaponPhysCannon::PHYSCANNON_ENDCAP1)+1)
#define NUM_PHYSCANNON_BEAMS 3
virtual int DrawModel( int flags );
virtual void ViewModelDrawn( C_BaseViewModel *pBaseViewModel );
virtual bool IsTransparent( void );
virtual void OnDataChanged( DataUpdateType_t type );
virtual void ClientThink( void );
void ManagePredictedObject( void );
void DrawEffects( void );
void GetEffectParameters( EffectType_t effectID, color32 &color, float &scale, IMaterial **pMaterial, Vector &vecAttachment );
void DrawEffectSprite( EffectType_t effectID );
inline bool IsEffectVisible( EffectType_t effectID );
void UpdateElementPosition( void );
// We need to render opaque and translucent pieces
RenderGroup_t GetRenderGroup( void ) { return RENDER_GROUP_TWOPASS; }
CInterpolatedValue m_ElementParameter; // Used to interpolate the position of the articulated elements
CPhysCannonEffect m_Parameters[NUM_PHYSCANNON_PARAMETERS]; // Interpolated parameters for the effects
CPhysCannonEffectBeam m_Beams[NUM_PHYSCANNON_BEAMS]; // Beams
int m_nOldEffectState; // Used for parity checks
bool m_bOldOpen; // Used for parity checks
void NotifyShouldTransmit( ShouldTransmitState_t state );
#endif // CLIENT_DLL
int m_nChangeState; // For delayed state change of elements
float m_flCheckSuppressTime; // Amount of time to suppress the checking for targets
bool m_flLastDenySoundPlayed; // Debounce for deny sound
int m_nAttack2Debounce;
CNetworkVar( bool, m_bActive );
CNetworkVar( int, m_EffectState ); // Current state of the effects on the gun
CNetworkVar( bool, m_bOpen );
bool m_bResetOwnerEntity;
float m_flElementDebounce;
CSoundPatch *m_sndMotor; // Whirring sound for the gun
CGrabController m_grabController;
float m_flRepuntObjectTime;
EHANDLE m_hLastPuntedObject;
private:
CWeaponPhysCannon( const CWeaponPhysCannon & );
#ifndef CLIENT_DLL
DECLARE_ACTTABLE();
#endif
};
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponPhysCannon, DT_WeaponPhysCannon )
BEGIN_NETWORK_TABLE( CWeaponPhysCannon, DT_WeaponPhysCannon )
#ifdef CLIENT_DLL
RecvPropBool( RECVINFO( m_bActive ) ),
RecvPropEHandle( RECVINFO( m_hAttachedObject ) ),
RecvPropVector( RECVINFO( m_attachedPositionObjectSpace ) ),
RecvPropFloat( RECVINFO( m_attachedAnglesPlayerSpace[0] ) ),
RecvPropFloat( RECVINFO( m_attachedAnglesPlayerSpace[1] ) ),
RecvPropFloat( RECVINFO( m_attachedAnglesPlayerSpace[2] ) ),
RecvPropInt( RECVINFO( m_EffectState ) ),
RecvPropBool( RECVINFO( m_bOpen ) ),
#else
SendPropBool( SENDINFO( m_bActive ) ),
SendPropEHandle( SENDINFO( m_hAttachedObject ) ),
SendPropVector(SENDINFO( m_attachedPositionObjectSpace ), -1, SPROP_COORD),
SendPropAngle( SENDINFO_VECTORELEM(m_attachedAnglesPlayerSpace, 0 ), 11 ),
SendPropAngle( SENDINFO_VECTORELEM(m_attachedAnglesPlayerSpace, 1 ), 11 ),
SendPropAngle( SENDINFO_VECTORELEM(m_attachedAnglesPlayerSpace, 2 ), 11 ),
SendPropInt( SENDINFO( m_EffectState ) ),
SendPropBool( SENDINFO( m_bOpen ) ),
#endif
END_NETWORK_TABLE()
#ifdef CLIENT_DLL
BEGIN_PREDICTION_DATA( CWeaponPhysCannon )
DEFINE_PRED_FIELD( m_EffectState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bOpen, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
END_PREDICTION_DATA()
#endif
LINK_ENTITY_TO_CLASS( weapon_physcannon, CWeaponPhysCannon );
PRECACHE_WEAPON_REGISTER( weapon_physcannon );
#ifndef CLIENT_DLL
acttable_t CWeaponPhysCannon::m_acttable[] =
{
{ ACT_HL2MP_IDLE, ACT_HL2MP_IDLE_PHYSGUN, false },
{ ACT_HL2MP_RUN, ACT_HL2MP_RUN_PHYSGUN, false },
{ ACT_HL2MP_IDLE_CROUCH, ACT_HL2MP_IDLE_CROUCH_PHYSGUN, false },
{ ACT_HL2MP_WALK_CROUCH, ACT_HL2MP_WALK_CROUCH_PHYSGUN, false },
{ ACT_HL2MP_GESTURE_RANGE_ATTACK, ACT_HL2MP_GESTURE_RANGE_ATTACK_PHYSGUN, false },
{ ACT_HL2MP_GESTURE_RELOAD, ACT_HL2MP_GESTURE_RELOAD_PHYSGUN, false },
{ ACT_HL2MP_JUMP, ACT_HL2MP_JUMP_PHYSGUN, false },
};
IMPLEMENT_ACTTABLE(CWeaponPhysCannon);
#endif
enum
{
ELEMENT_STATE_NONE = -1,
ELEMENT_STATE_OPEN,
ELEMENT_STATE_CLOSED,
};
enum
{
EFFECT_NONE,
EFFECT_CLOSED,
EFFECT_READY,
EFFECT_HOLDING,
EFFECT_LAUNCH,
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CWeaponPhysCannon::CWeaponPhysCannon( void )
{
m_bOpen = false;
m_nChangeState = ELEMENT_STATE_NONE;
m_flCheckSuppressTime = 0.0f;
m_EffectState = (int)EFFECT_NONE;
m_flLastDenySoundPlayed = false;
#ifdef CLIENT_DLL
m_nOldEffectState = EFFECT_NONE;
m_bOldOpen = false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Precache
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::Precache( void )
{
PrecacheModel( PHYSCANNON_BEAM_SPRITE );
PrecacheModel( PHYSCANNON_BEAM_SPRITE_NOZ );
PrecacheScriptSound( "Weapon_PhysCannon.HoldSound" );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose: Restore
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::OnRestore()
{
BaseClass::OnRestore();
m_grabController.OnRestore();
// Tracker 8106: Physcannon effects disappear through level transition, so
// just recreate any effects here
if ( m_EffectState != EFFECT_NONE )
{
DoEffect( m_EffectState, NULL );
}
}
//-----------------------------------------------------------------------------
// On Remove
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::UpdateOnRemove(void)
{
DestroyEffects( );
BaseClass::UpdateOnRemove();
}
#ifdef CLIENT_DLL
void CWeaponPhysCannon::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, false );
StartEffects();
}
if ( GetOwner() == NULL )
{
if ( m_hAttachedObject )
{
m_hAttachedObject->VPhysicsDestroyObject();
}
if ( m_hOldAttachedObject )
{
m_hOldAttachedObject->VPhysicsDestroyObject();
}
}
// Update effect state when out of parity with the server
if ( m_nOldEffectState != m_EffectState )
{
DoEffect( m_EffectState );
m_nOldEffectState = m_EffectState;
}
// Update element state when out of parity
if ( m_bOldOpen != m_bOpen )
{
if ( m_bOpen )
{
m_ElementParameter.InitFromCurrent( 1.0f, 0.2f, INTERP_SPLINE );
}
else
{
m_ElementParameter.InitFromCurrent( 0.0f, 0.5f, INTERP_SPLINE );
}
m_bOldOpen = (bool) m_bOpen;
}
}
#endif
//-----------------------------------------------------------------------------
// Sprite scale factor
//-----------------------------------------------------------------------------
inline float CWeaponPhysCannon::SpriteScaleFactor()
{
return 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::Deploy( void )
{
CloseElements();
DoEffect( EFFECT_READY );
bool bReturn = BaseClass::Deploy();
m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->curtime;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner )
{
pOwner->SetNextAttack( gpGlobals->curtime );
}
return bReturn;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::SetViewModel( void )
{
BaseClass::SetViewModel();
}
//-----------------------------------------------------------------------------
// Purpose: Force the cannon to drop anything it's carrying
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ForceDrop( void )
{
CloseElements();
DetachObject();
StopEffects();
}
//-----------------------------------------------------------------------------
// Purpose: Drops its held entity if it matches the entity passed in
// Input : *pTarget -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::DropIfEntityHeld( CBaseEntity *pTarget )
{
if ( pTarget == NULL )
return false;
CBaseEntity *pHeld = m_grabController.GetAttached();
if ( pHeld == NULL )
return false;
if ( pHeld == pTarget )
{
ForceDrop();
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::Drop( const Vector &vecVelocity )
{
ForceDrop();
#ifndef CLIENT_DLL
UTIL_Remove( this );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::CanHolster( void )
{
//Don't holster this weapon if we're holding onto something
if ( m_bActive )
return false;
return BaseClass::CanHolster();
};
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::Holster( CBaseCombatWeapon *pSwitchingTo )
{
//Don't holster this weapon if we're holding onto something
if ( m_bActive )
return false;
ForceDrop();
DestroyEffects();
return BaseClass::Holster( pSwitchingTo );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DryFire( void )
{
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
WeaponSound( EMPTY );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::PrimaryFireEffect( void )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
pOwner->ViewPunch( QAngle(-6, SharedRandomInt( "physcannonfire", -2,2) ,0) );
#ifndef CLIENT_DLL
color32 white = { 245, 245, 255, 32 };
UTIL_ScreenFade( pOwner, white, 0.1f, 0.0f, FFADE_IN );
#endif
WeaponSound( SINGLE );
}
#define MAX_KNOCKBACK_FORCE 128
//-----------------------------------------------------------------------------
// Punt non-physics
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::PuntNonVPhysics( CBaseEntity *pEntity, const Vector &forward, trace_t &tr )
{
if ( m_hLastPuntedObject == pEntity && gpGlobals->curtime < m_flRepuntObjectTime )
return;
#ifndef CLIENT_DLL
CTakeDamageInfo info;
info.SetAttacker( GetOwner() );
info.SetInflictor( this );
info.SetDamage( 1.0f );
info.SetDamageType( DMG_CRUSH | DMG_PHYSGUN );
info.SetDamageForce( forward ); // Scale?
info.SetDamagePosition( tr.endpos );
m_hLastPuntedObject = pEntity;
m_flRepuntObjectTime = gpGlobals->curtime + 0.5f;
pEntity->DispatchTraceAttack( info, forward, &tr );
ApplyMultiDamage();
//Explosion effect
DoEffect( EFFECT_LAUNCH, &tr.endpos );
#endif
PrimaryFireEffect();
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
m_nChangeState = ELEMENT_STATE_CLOSED;
m_flElementDebounce = gpGlobals->curtime + 0.5f;
m_flCheckSuppressTime = gpGlobals->curtime + 0.25f;
}
#ifndef CLIENT_DLL
//-----------------------------------------------------------------------------
// What happens when the physgun picks up something
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::Physgun_OnPhysGunPickup( CBaseEntity *pEntity, CBasePlayer *pOwner, PhysGunPickup_t reason )
{
// If the target is debris, convert it to non-debris
if ( pEntity->GetCollisionGroup() == COLLISION_GROUP_DEBRIS )
{
// Interactive debris converts back to debris when it comes to rest
pEntity->SetCollisionGroup( COLLISION_GROUP_INTERACTIVE_DEBRIS );
}
Pickup_OnPhysGunPickup( pEntity, pOwner, reason );
}
#endif
//-----------------------------------------------------------------------------
// Punt vphysics
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::PuntVPhysics( CBaseEntity *pEntity, const Vector &vecForward, trace_t &tr )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( m_hLastPuntedObject == pEntity && gpGlobals->curtime < m_flRepuntObjectTime )
return;
m_hLastPuntedObject = pEntity;
m_flRepuntObjectTime = gpGlobals->curtime + 0.5f;
#ifndef CLIENT_DLL
CTakeDamageInfo info;
Vector forward = vecForward;
info.SetAttacker( GetOwner() );
info.SetInflictor( this );
info.SetDamage( 0.0f );
info.SetDamageType( DMG_PHYSGUN );
pEntity->DispatchTraceAttack( info, forward, &tr );
ApplyMultiDamage();
if ( Pickup_OnAttemptPhysGunPickup( pEntity, pOwner, PUNTED_BY_CANNON ) )
{
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int listCount = pEntity->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
if ( !listCount )
{
//FIXME: Do we want to do this if there's no physics object?
Physgun_OnPhysGunPickup( pEntity, pOwner, PUNTED_BY_CANNON );
DryFire();
return;
}
if( forward.z < 0 )
{
//reflect, but flatten the trajectory out a bit so it's easier to hit standing targets
forward.z *= -0.65f;
}
// NOTE: Do this first to enable motion (if disabled) - so forces will work
// Tell the object it's been punted
Physgun_OnPhysGunPickup( pEntity, pOwner, PUNTED_BY_CANNON );
// don't push vehicles that are attached to the world via fixed constraints
// they will just wiggle...
if ( (pList[0]->GetGameFlags() & FVPHYSICS_CONSTRAINT_STATIC) && pEntity->GetServerVehicle() )
{
forward.Init();
}
if ( !Pickup_ShouldPuntUseLaunchForces( pEntity, PHYSGUN_FORCE_PUNTED ) )
{
int i;
// limit mass to avoid punting REALLY huge things
float totalMass = 0;
for ( i = 0; i < listCount; i++ )
{
totalMass += pList[i]->GetMass();
}
float maxMass = 250;
IServerVehicle *pVehicle = pEntity->GetServerVehicle();
if ( pVehicle )
{
maxMass *= 2.5; // 625 for vehicles
}
float mass = MIN(totalMass, maxMass); // max 250kg of additional force
// Put some spin on the object
for ( i = 0; i < listCount; i++ )
{
const float hitObjectFactor = 0.5f;
const float otherObjectFactor = 1.0f - hitObjectFactor;
// Must be light enough
float ratio = pList[i]->GetMass() / totalMass;
if ( pList[i] == pEntity->VPhysicsGetObject() )
{
ratio += hitObjectFactor;
ratio = MIN(ratio,1.0f);
}
else
{
ratio *= otherObjectFactor;
}
pList[i]->ApplyForceCenter( forward * 15000.0f * ratio );
pList[i]->ApplyForceOffset( forward * mass * 600.0f * ratio, tr.endpos );
}
}
else
{
ApplyVelocityBasedForce( pEntity, vecForward );
}
}
#endif
// Add recoil
QAngle recoil = QAngle( random->RandomFloat( 1.0f, 2.0f ), random->RandomFloat( -1.0f, 1.0f ), 0 );
pOwner->ViewPunch( recoil );
//Explosion effect
DoEffect( EFFECT_LAUNCH, &tr.endpos );
PrimaryFireEffect();
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
m_nChangeState = ELEMENT_STATE_CLOSED;
m_flElementDebounce = gpGlobals->curtime + 0.5f;
m_flCheckSuppressTime = gpGlobals->curtime + 0.25f;
// Don't allow the gun to regrab a thrown object!!
m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
}
//-----------------------------------------------------------------------------
// Purpose: Applies velocity-based forces to throw the entity. This code is
// called from both punt and launch carried code.
// ASSUMES: that pEntity is a vphysics entity.
// Input : -
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ApplyVelocityBasedForce( CBaseEntity *pEntity, const Vector &forward )
{
#ifndef CLIENT_DLL
IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();
Assert(pPhysicsObject); // Shouldn't ever get here with a non-vphysics object.
if (!pPhysicsObject)
return;
float flForceMax = physcannon_maxforce.GetFloat();
float flForce = flForceMax;
float mass = pPhysicsObject->GetMass();
if (mass > 100)
{
mass = MIN(mass, 1000);
float flForceMin = physcannon_minforce.GetFloat();
flForce = SimpleSplineRemapVal(mass, 100, 600, flForceMax, flForceMin);
}
Vector vVel = forward * flForce;
// FIXME: Josh needs to put a real value in for PHYSGUN_FORCE_PUNTED
AngularImpulse aVel = Pickup_PhysGunLaunchAngularImpulse( pEntity, PHYSGUN_FORCE_PUNTED );
pPhysicsObject->AddVelocity( &vVel, &aVel );
#endif
}
//-----------------------------------------------------------------------------
// Trace length
//-----------------------------------------------------------------------------
float CWeaponPhysCannon::TraceLength()
{
return physcannon_tracelength.GetFloat();
}
//-----------------------------------------------------------------------------
// Purpose:
//
// This mode is a toggle. Primary fire one time to pick up a physics object.
// With an object held, click primary fire again to drop object.
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::PrimaryAttack( void )
{
if( m_flNextPrimaryAttack > gpGlobals->curtime )
return;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
if( m_bActive )
{
// Punch the object being held!!
Vector forward;
pOwner->EyeVectors( &forward );
// Validate the item is within punt range
CBaseEntity *pHeld = m_grabController.GetAttached();
Assert( pHeld != NULL );
if ( pHeld != NULL )
{
float heldDist = ( pHeld->WorldSpaceCenter() - pOwner->WorldSpaceCenter() ).Length();
if ( heldDist > physcannon_tracelength.GetFloat() )
{
// We can't punt this yet
DryFire();
return;
}
}
LaunchObject( forward, physcannon_maxforce.GetFloat() );
PrimaryFireEffect();
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
return;
}
// If not active, just issue a physics punch in the world.
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
Vector forward;
pOwner->EyeVectors( &forward );
// NOTE: Notice we're *not* using the mega tracelength here
// when you have the mega cannon. Punting has shorter range.
Vector start, end;
start = pOwner->Weapon_ShootPosition();
float flPuntDistance = physcannon_tracelength.GetFloat();
VectorMA( start, flPuntDistance, forward, end );
CTraceFilterNoOwnerTest filter( pOwner, COLLISION_GROUP_NONE );
trace_t tr;
UTIL_TraceHull( start, end, -Vector(8,8,8), Vector(8,8,8), MASK_SHOT|CONTENTS_GRATE, &filter, &tr );
bool bValid = true;
CBaseEntity *pEntity = tr.m_pEnt;
if ( tr.fraction == 1 || !tr.m_pEnt || tr.m_pEnt->IsEFlagSet( EFL_NO_PHYSCANNON_INTERACTION ) )
{
bValid = false;
}
else if ( (pEntity->GetMoveType() != MOVETYPE_VPHYSICS) && ( pEntity->m_takedamage == DAMAGE_NO ) )
{
bValid = false;
}
// If the entity we've hit is invalid, try a traceline instead
if ( !bValid )
{
UTIL_TraceLine( start, end, MASK_SHOT|CONTENTS_GRATE, &filter, &tr );
if ( tr.fraction == 1 || !tr.m_pEnt || tr.m_pEnt->IsEFlagSet( EFL_NO_PHYSCANNON_INTERACTION ) )
{
// Play dry-fire sequence
DryFire();
return;
}
pEntity = tr.m_pEnt;
}
// See if we hit something
if ( pEntity->GetMoveType() != MOVETYPE_VPHYSICS )
{
if ( pEntity->m_takedamage == DAMAGE_NO )
{
DryFire();
return;
}
if( GetOwner()->IsPlayer() )
{
// Don't let the player zap any NPC's except regular antlions and headcrabs.
if( pEntity->IsPlayer() )
{
DryFire();
return;
}
}
PuntNonVPhysics( pEntity, forward, tr );
}
else
{
if ( pEntity->VPhysicsIsFlesh( ) )
{
DryFire();
return;
}
PuntVPhysics( pEntity, forward, tr );
}
}
//-----------------------------------------------------------------------------
// Purpose: Click secondary attack whilst holding an object to hurl it.
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::SecondaryAttack( void )
{
#ifndef CLIENT_DLL
if ( m_flNextSecondaryAttack > gpGlobals->curtime )
return;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
// See if we should drop a held item
if ( ( m_bActive ) && ( pOwner->m_afButtonPressed & IN_ATTACK2 ) )
{
// Drop the held object
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
DetachObject();
DoEffect( EFFECT_READY );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
}
else
{
// Otherwise pick it up
FindObjectResult_t result = FindObject();
switch ( result )
{
case OBJECT_FOUND:
WeaponSound( SPECIAL1 );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5f;
// We found an object. Debounce the button
m_nAttack2Debounce |= pOwner->m_nButtons;
break;
case OBJECT_NOT_FOUND:
m_flNextSecondaryAttack = gpGlobals->curtime + 0.1f;
CloseElements();
break;
case OBJECT_BEING_DETACHED:
m_flNextSecondaryAttack = gpGlobals->curtime + 0.01f;
break;
}
DoEffect( EFFECT_HOLDING );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::WeaponIdle( void )
{
if ( HasWeaponIdleTimeElapsed() )
{
if ( m_bActive )
{
//Shake when holding an item
SendWeaponAnim( ACT_VM_RELOAD );
}
else
{
//Otherwise idle simply
SendWeaponAnim( ACT_VM_IDLE );
}
}
}
#ifndef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObject -
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::AttachObject( CBaseEntity *pObject, const Vector &vPosition )
{
if ( m_bActive )
return false;
if ( CanPickupObject( pObject ) == false )
return false;
m_grabController.SetIgnorePitch( false );
m_grabController.SetAngleAlignment( 0 );
IPhysicsObject *pPhysics = pObject->VPhysicsGetObject();
// Must be valid
if ( !pPhysics )
return false;
CHL2MP_Player *pOwner = (CHL2MP_Player *)ToBasePlayer( GetOwner() );
m_bActive = true;
if( pOwner )
{
// NOTE: This can change the mass; so it must be done before max speed setting
Physgun_OnPhysGunPickup( pObject, pOwner, PICKED_UP_BY_CANNON );
}
// NOTE :This must happen after OnPhysGunPickup because that can change the mass
m_grabController.AttachEntity( pOwner, pObject, pPhysics, false, vPosition, false );
m_hAttachedObject = pObject;
m_attachedPositionObjectSpace = m_grabController.m_attachedPositionObjectSpace;
m_attachedAnglesPlayerSpace = m_grabController.m_attachedAnglesPlayerSpace;
m_bResetOwnerEntity = false;
if ( m_hAttachedObject->GetOwnerEntity() == NULL )
{
m_hAttachedObject->SetOwnerEntity( pOwner );
m_bResetOwnerEntity = true;
}
/* if( pOwner )
{
pOwner->EnableSprint( false );
float loadWeight = ( 1.0f - GetLoadPercentage() );
float maxSpeed = hl2_walkspeed.GetFloat() + ( ( hl2_normspeed.GetFloat() - hl2_walkspeed.GetFloat() ) * loadWeight );
//Msg( "Load perc: %f -- Movement speed: %f/%f\n", loadWeight, maxSpeed, hl2_normspeed.GetFloat() );
pOwner->SetMaxSpeed( maxSpeed );
}*/
// Don't drop again for a slight delay, in case they were pulling objects near them
m_flNextSecondaryAttack = gpGlobals->curtime + 0.4f;
DoEffect( EFFECT_HOLDING );
OpenElements();
if ( GetMotorSound() )
{
(CSoundEnvelopeController::GetController()).Play( GetMotorSound(), 0.0f, 50 );
(CSoundEnvelopeController::GetController()).SoundChangePitch( GetMotorSound(), 100, 0.5f );
(CSoundEnvelopeController::GetController()).SoundChangeVolume( GetMotorSound(), 0.8f, 0.5f );
}
return true;
}
CWeaponPhysCannon::FindObjectResult_t CWeaponPhysCannon::FindObject( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
Assert( pPlayer );
if ( pPlayer == NULL )
return OBJECT_NOT_FOUND;
Vector forward;
pPlayer->EyeVectors( &forward );
// Setup our positions
Vector start = pPlayer->Weapon_ShootPosition();
float testLength = TraceLength() * 4.0f;
Vector end = start + forward * testLength;
// Try to find an object by looking straight ahead
trace_t tr;
CTraceFilterNoOwnerTest filter( pPlayer, COLLISION_GROUP_NONE );
UTIL_TraceLine( start, end, MASK_SHOT|CONTENTS_GRATE, &filter, &tr );
// Try again with a hull trace
if ( ( tr.fraction == 1.0 ) || ( tr.m_pEnt == NULL ) || ( tr.m_pEnt->IsWorld() ) )
{
UTIL_TraceHull( start, end, -Vector(4,4,4), Vector(4,4,4), MASK_SHOT|CONTENTS_GRATE, &filter, &tr );
}
CBaseEntity *pEntity = tr.m_pEnt ? tr.m_pEnt->GetRootMoveParent() : NULL;
bool bAttach = false;
bool bPull = false;
// If we hit something, pick it up or pull it
if ( ( tr.fraction != 1.0f ) && ( tr.m_pEnt ) && ( tr.m_pEnt->IsWorld() == false ) )
{
// Attempt to attach if within range
if ( tr.fraction <= 0.25f )
{
bAttach = true;
}
else if ( tr.fraction > 0.25f )
{
bPull = true;
}
}
// Find anything within a general cone in front
CBaseEntity *pConeEntity = NULL;
if (!bAttach && !bPull)
{
pConeEntity = FindObjectInCone( start, forward, physcannon_cone.GetFloat() );
}
if ( pConeEntity )
{
pEntity = pConeEntity;
// If the object is near, grab it. Else, pull it a bit.
if ( pEntity->WorldSpaceCenter().DistToSqr( start ) <= (testLength * testLength) )
{
bAttach = true;
}
else
{
bPull = true;
}
}
if ( CanPickupObject( pEntity ) == false )
{
// Make a noise to signify we can't pick this up
if ( !m_flLastDenySoundPlayed )
{
m_flLastDenySoundPlayed = true;
WeaponSound( SPECIAL3 );
}
return OBJECT_NOT_FOUND;
}
// Check to see if the object is constrained + needs to be ripped off...
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !Pickup_OnAttemptPhysGunPickup( pEntity, pOwner, PICKED_UP_BY_CANNON ) )
return OBJECT_BEING_DETACHED;
if ( bAttach )
{
return AttachObject( pEntity, tr.endpos ) ? OBJECT_FOUND : OBJECT_NOT_FOUND;
}
if ( !bPull )
return OBJECT_NOT_FOUND;
// FIXME: This needs to be run through the CanPickupObject logic
IPhysicsObject *pObj = pEntity->VPhysicsGetObject();
if ( !pObj )
return OBJECT_NOT_FOUND;
// If we're too far, simply start to pull the object towards us
Vector pullDir = start - pEntity->WorldSpaceCenter();
VectorNormalize( pullDir );
pullDir *= physcannon_pullforce.GetFloat();
float mass = PhysGetEntityMass( pEntity );
if ( mass < 50.0f )
{
pullDir *= (mass + 0.5) * (1/50.0f);
}
// Nudge it towards us
pObj->ApplyForceCenter( pullDir );
return OBJECT_NOT_FOUND;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CBaseEntity *CWeaponPhysCannon::FindObjectInCone( const Vector &vecOrigin, const Vector &vecDir, float flCone )
{
// Find the nearest physics-based item in a cone in front of me.
CBaseEntity *list[256];
float flNearestDist = TraceLength() + 1.0;
Vector mins = vecOrigin - Vector( flNearestDist, flNearestDist, flNearestDist );
Vector maxs = vecOrigin + Vector( flNearestDist, flNearestDist, flNearestDist );
CBaseEntity *pNearest = NULL;
int count = UTIL_EntitiesInBox( list, 256, mins, maxs, 0 );
for( int i = 0 ; i < count ; i++ )
{
if ( !list[ i ]->VPhysicsGetObject() )
continue;
// Closer than other objects
Vector los = ( list[ i ]->WorldSpaceCenter() - vecOrigin );
float flDist = VectorNormalize( los );
if( flDist >= flNearestDist )
continue;
// Cull to the cone
if ( DotProduct( los, vecDir ) <= flCone )
continue;
// Make sure it isn't occluded!
trace_t tr;
CTraceFilterNoOwnerTest filter( GetOwner(), COLLISION_GROUP_NONE );
UTIL_TraceLine( vecOrigin, list[ i ]->WorldSpaceCenter(), MASK_SHOT|CONTENTS_GRATE, &filter, &tr );
if( tr.m_pEnt == list[ i ] )
{
flNearestDist = flDist;
pNearest = list[ i ];
}
}
return pNearest;
}
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CGrabController::UpdateObject( CBasePlayer *pPlayer, float flError )
{
CBaseEntity *pEntity = GetAttached();
if ( !pEntity )
return false;
if ( ComputeError() > flError )
return false;
if ( pPlayer->GetGroundEntity() == pEntity )
return false;
if (!pEntity->VPhysicsGetObject() )
return false;
//Adrian: Oops, our object became motion disabled, let go!
IPhysicsObject *pPhys = pEntity->VPhysicsGetObject();
if ( pPhys && pPhys->IsMoveable() == false )
{
return false;
}
if ( m_frameCount == gpGlobals->framecount )
{
return true;
}
m_frameCount = gpGlobals->framecount;
Vector forward, right, up;
QAngle playerAngles = pPlayer->EyeAngles();
float pitch = AngleDistance(playerAngles.x,0);
playerAngles.x = clamp( pitch, -75, 75 );
AngleVectors( playerAngles, &forward, &right, &up );
// Now clamp a sphere of object radius at end to the player's bbox
Vector radial = physcollision->CollideGetExtent( pPhys->GetCollide(), vec3_origin, pEntity->GetAbsAngles(), -forward );
Vector player2d = pPlayer->CollisionProp()->OBBMaxs();
float playerRadius = player2d.Length2D();
float flDot = DotProduct( forward, radial );
float radius = playerRadius + fabs( flDot );
float distance = 24 + ( radius * 2.0f );
Vector start = pPlayer->Weapon_ShootPosition();
Vector end = start + ( forward * distance );
trace_t tr;
CTraceFilterSkipTwoEntities traceFilter( pPlayer, pEntity, COLLISION_GROUP_NONE );
Ray_t ray;
ray.Init( start, end );
enginetrace->TraceRay( ray, MASK_SOLID_BRUSHONLY, &traceFilter, &tr );
if ( tr.fraction < 0.5 )
{
end = start + forward * (radius*0.5f);
}
else if ( tr.fraction <= 1.0f )
{
end = start + forward * ( distance - radius );
}
Vector playerMins, playerMaxs, nearest;
pPlayer->CollisionProp()->WorldSpaceAABB( &playerMins, &playerMaxs );
Vector playerLine = pPlayer->CollisionProp()->WorldSpaceCenter();
CalcClosestPointOnLine( end, playerLine+Vector(0,0,playerMins.z), playerLine+Vector(0,0,playerMaxs.z), nearest, NULL );
Vector delta = end - nearest;
float len = VectorNormalize(delta);
if ( len < radius )
{
end = nearest + radius * delta;
}
QAngle angles = TransformAnglesFromPlayerSpace( m_attachedAnglesPlayerSpace, pPlayer );
//Show overlays of radius
if ( g_debug_physcannon.GetBool() )
{
#ifdef CLIENT_DLL
debugoverlay->AddBoxOverlay( end, -Vector( 2,2,2 ), Vector(2,2,2), angles, 0, 255, 255, true, 0 );
debugoverlay->AddBoxOverlay( GetAttached()->WorldSpaceCenter(),
-Vector( radius, radius, radius),
Vector( radius, radius, radius ),
angles,
255, 255, 0,
true,
0.0f );
#else
NDebugOverlay::Box( end, -Vector( 2,2,2 ), Vector(2,2,2), 0, 255, 0, true, 0 );
NDebugOverlay::Box( GetAttached()->WorldSpaceCenter(),
-Vector( radius+5, radius+5, radius+5),
Vector( radius+5, radius+5, radius+5 ),
255, 0, 0,
true,
0.0f );
#endif
}
#ifndef CLIENT_DLL
// If it has a preferred orientation, update to ensure we're still oriented correctly.
Pickup_GetPreferredCarryAngles( pEntity, pPlayer, pPlayer->EntityToWorldTransform(), angles );
// We may be holding a prop that has preferred carry angles
if ( m_bHasPreferredCarryAngles )
{
matrix3x4_t tmp;
ComputePlayerMatrix( pPlayer, tmp );
angles = TransformAnglesToWorldSpace( m_vecPreferredCarryAngles, tmp );
}
#endif
matrix3x4_t attachedToWorld;
Vector offset;
AngleMatrix( angles, attachedToWorld );
VectorRotate( m_attachedPositionObjectSpace, attachedToWorld, offset );
SetTargetPosition( end - offset, angles );
return true;
}
void CWeaponPhysCannon::UpdateObject( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
Assert( pPlayer );
float flError = 12;
if ( !m_grabController.UpdateObject( pPlayer, flError ) )
{
DetachObject();
return;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DetachObject( bool playSound, bool wasLaunched )
{
#ifndef CLIENT_DLL
if ( m_bActive == false )
return;
CHL2MP_Player *pOwner = (CHL2MP_Player *)ToBasePlayer( GetOwner() );
if( pOwner != NULL )
{
pOwner->EnableSprint( true );
pOwner->SetMaxSpeed( hl2_normspeed.GetFloat() );
}
CBaseEntity *pObject = m_grabController.GetAttached();
m_grabController.DetachEntity( wasLaunched );
if ( pObject != NULL )
{
Pickup_OnPhysGunDrop( pObject, pOwner, wasLaunched ? LAUNCHED_BY_CANNON : DROPPED_BY_CANNON );
}
// Stop our looping sound
if ( GetMotorSound() )
{
(CSoundEnvelopeController::GetController()).SoundChangeVolume( GetMotorSound(), 0.0f, 1.0f );
(CSoundEnvelopeController::GetController()).SoundChangePitch( GetMotorSound(), 50, 1.0f );
}
if ( pObject && m_bResetOwnerEntity == true )
{
pObject->SetOwnerEntity( NULL );
}
m_bActive = false;
m_hAttachedObject = NULL;
if ( playSound )
{
//Play the detach sound
WeaponSound( MELEE_MISS );
}
#else
m_grabController.DetachEntity( wasLaunched );
if ( m_hAttachedObject )
{
m_hAttachedObject->VPhysicsDestroyObject();
}
#endif
}
#ifdef CLIENT_DLL
void CWeaponPhysCannon::ManagePredictedObject( void )
{
CBaseEntity *pAttachedObject = m_hAttachedObject.Get();
if ( m_hAttachedObject )
{
// NOTE :This must happen after OnPhysGunPickup because that can change the mass
if ( pAttachedObject != GetGrabController().GetAttached() )
{
IPhysicsObject *pPhysics = pAttachedObject->VPhysicsGetObject();
if ( pPhysics == NULL )
{
solid_t tmpSolid;
PhysModelParseSolid( tmpSolid, m_hAttachedObject, pAttachedObject->GetModelIndex() );
pAttachedObject->VPhysicsInitNormal( SOLID_VPHYSICS, 0, false, &tmpSolid );
}
pPhysics = pAttachedObject->VPhysicsGetObject();
if ( pPhysics )
{
m_grabController.SetIgnorePitch( false );
m_grabController.SetAngleAlignment( 0 );
GetGrabController().AttachEntity( ToBasePlayer( GetOwner() ), pAttachedObject, pPhysics, false, vec3_origin, false );
GetGrabController().m_attachedPositionObjectSpace = m_attachedPositionObjectSpace;
GetGrabController().m_attachedAnglesPlayerSpace = m_attachedAnglesPlayerSpace;
}
}
}
else
{
if ( m_hOldAttachedObject && m_hOldAttachedObject->VPhysicsGetObject() )
{
GetGrabController().DetachEntity( false );
m_hOldAttachedObject->VPhysicsDestroyObject();
}
}
m_hOldAttachedObject = m_hAttachedObject;
}
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Update the pose parameter for the gun
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::UpdateElementPosition( void )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
float flElementPosition = m_ElementParameter.Interp( gpGlobals->curtime );
if ( ShouldDrawUsingViewModel() )
{
if ( pOwner != NULL )
{
CBaseViewModel *vm = pOwner->GetViewModel();
if ( vm != NULL )
{
vm->SetPoseParameter( "active", flElementPosition );
}
}
}
else
{
SetPoseParameter( "active", flElementPosition );
}
}
//-----------------------------------------------------------------------------
// Purpose: Think function for the client
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ClientThink( void )
{
// Update our elements visually
UpdateElementPosition();
// Update our effects
DoEffectIdle();
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ItemPreFrame()
{
BaseClass::ItemPreFrame();
#ifdef CLIENT_DLL
C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
if ( localplayer && !localplayer->IsObserver() )
ManagePredictedObject();
#endif
// Update the object if the weapon is switched on.
if( m_bActive )
{
UpdateObject();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::CheckForTarget( void )
{
#ifndef CLIENT_DLL
//See if we're suppressing this
if ( m_flCheckSuppressTime > gpGlobals->curtime )
return;
// holstered
if ( IsEffectActive( EF_NODRAW ) )
return;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
if ( m_bActive )
return;
Vector aimDir;
pOwner->EyeVectors( &aimDir );
Vector startPos = pOwner->Weapon_ShootPosition();
Vector endPos;
VectorMA( startPos, TraceLength(), aimDir, endPos );
trace_t tr;
UTIL_TraceHull( startPos, endPos, -Vector(4,4,4), Vector(4,4,4), MASK_SHOT|CONTENTS_GRATE, pOwner, COLLISION_GROUP_NONE, &tr );
if ( ( tr.fraction != 1.0f ) && ( tr.m_pEnt != NULL ) )
{
// FIXME: Try just having the elements always open when pointed at a physics object
if ( CanPickupObject( tr.m_pEnt ) || Pickup_ForcePhysGunOpen( tr.m_pEnt, pOwner ) )
// if ( ( tr.m_pEnt->VPhysicsGetObject() != NULL ) && ( tr.m_pEnt->GetMoveType() == MOVETYPE_VPHYSICS ) )
{
m_nChangeState = ELEMENT_STATE_NONE;
OpenElements();
return;
}
}
// Close the elements after a delay to prevent overact state switching
if ( ( m_flElementDebounce < gpGlobals->curtime ) && ( m_nChangeState == ELEMENT_STATE_NONE ) )
{
m_nChangeState = ELEMENT_STATE_CLOSED;
m_flElementDebounce = gpGlobals->curtime + 0.5f;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Idle effect (pulsing)
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectIdle( void )
{
#ifdef CLIENT_DLL
StartEffects();
//if ( ShouldDrawUsingViewModel() )
{
// Turn on the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].GetScale().SetAbsolute( random->RandomFloat( 0.075f, 0.05f ) * SPRITE_SCALE );
m_Parameters[i].GetAlpha().SetAbsolute( random->RandomInt( 24, 32 ) );
}
// Turn on the glow sprites
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].GetScale().SetAbsolute( random->RandomFloat( 3, 5 ) );
m_Parameters[i].GetAlpha().SetAbsolute( random->RandomInt( 200, 255 ) );
}
if ( m_EffectState != EFFECT_HOLDING )
{
// Turn beams off
m_Beams[0].SetVisible( false );
m_Beams[1].SetVisible( false );
m_Beams[2].SetVisible( false );
}
}
/*
else
{
// Turn on the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].GetScale().SetAbsolute( random->RandomFloat( 0.075f, 0.05f ) * SPRITE_SCALE );
m_Parameters[i].GetAlpha().SetAbsolute( random->RandomInt( 24, 32 ) );
}
// Turn on the glow sprites
for ( i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].GetScale().SetAbsolute( random->RandomFloat( 3, 5 ) );
m_Parameters[i].GetAlpha().SetAbsolute( random->RandomInt( 200, 255 ) );
}
if ( m_EffectState != EFFECT_HOLDING )
{
// Turn beams off
m_Beams[0].SetVisible( false );
m_Beams[1].SetVisible( false );
m_Beams[2].SetVisible( false );
}
}
*/
#endif
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ItemPostFrame()
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
{
// We found an object. Debounce the button
m_nAttack2Debounce = 0;
return;
}
//Check for object in pickup range
if ( m_bActive == false )
{
CheckForTarget();
if ( ( m_flElementDebounce < gpGlobals->curtime ) && ( m_nChangeState != ELEMENT_STATE_NONE ) )
{
if ( m_nChangeState == ELEMENT_STATE_OPEN )
{
OpenElements();
}
else if ( m_nChangeState == ELEMENT_STATE_CLOSED )
{
CloseElements();
}
m_nChangeState = ELEMENT_STATE_NONE;
}
}
// NOTE: Attack2 will be considered to be pressed until the first item is picked up.
int nAttack2Mask = pOwner->m_nButtons & (~m_nAttack2Debounce);
if ( nAttack2Mask & IN_ATTACK2 )
{
SecondaryAttack();
}
else
{
// Reset our debouncer
m_flLastDenySoundPlayed = false;
if ( m_bActive == false )
{
DoEffect( EFFECT_READY );
}
}
if (( pOwner->m_nButtons & IN_ATTACK2 ) == 0 )
{
m_nAttack2Debounce = 0;
}
if ( pOwner->m_nButtons & IN_ATTACK )
{
PrimaryAttack();
}
else
{
WeaponIdle();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#define PHYSCANNON_DANGER_SOUND_RADIUS 128
void CWeaponPhysCannon::LaunchObject( const Vector &vecDir, float flForce )
{
CBaseEntity *pObject = m_grabController.GetAttached();
if ( !(m_hLastPuntedObject == pObject && gpGlobals->curtime < m_flRepuntObjectTime) )
{
// FIRE!!!
if( pObject != NULL )
{
DetachObject( false, true );
m_hLastPuntedObject = pObject;
m_flRepuntObjectTime = gpGlobals->curtime + 0.5f;
// Launch
ApplyVelocityBasedForce( pObject, vecDir );
// Don't allow the gun to regrab a thrown object!!
m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
Vector center = pObject->WorldSpaceCenter();
//Do repulse effect
DoEffect( EFFECT_LAUNCH, &center );
m_hAttachedObject = NULL;
m_bActive = false;
}
}
// Stop our looping sound
if ( GetMotorSound() )
{
(CSoundEnvelopeController::GetController()).SoundChangeVolume( GetMotorSound(), 0.0f, 1.0f );
(CSoundEnvelopeController::GetController()).SoundChangePitch( GetMotorSound(), 50, 1.0f );
}
//Close the elements and suppress checking for a bit
m_nChangeState = ELEMENT_STATE_CLOSED;
m_flElementDebounce = gpGlobals->curtime + 0.1f;
m_flCheckSuppressTime = gpGlobals->curtime + 0.25f;
}
bool UTIL_IsCombineBall( CBaseEntity *pEntity );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pTarget -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::CanPickupObject( CBaseEntity *pTarget )
{
#ifndef CLIENT_DLL
if ( pTarget == NULL )
return false;
if ( pTarget->GetBaseAnimating() && pTarget->GetBaseAnimating()->IsDissolving() )
return false;
if ( pTarget->IsEFlagSet( EFL_NO_PHYSCANNON_INTERACTION ) )
return false;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner && pOwner->GetGroundEntity() == pTarget )
return false;
if ( pTarget->VPhysicsIsFlesh( ) )
return false;
IPhysicsObject *pObj = pTarget->VPhysicsGetObject();
if ( pObj && pObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
return false;
if ( UTIL_IsCombineBall( pTarget ) )
{
return CBasePlayer::CanPickupObject( pTarget, 0, 0 );
}
return CBasePlayer::CanPickupObject( pTarget, physcannon_maxmass.GetFloat(), 0 );
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::OpenElements( void )
{
if ( m_bOpen )
return;
WeaponSound( SPECIAL2 );
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
SendWeaponAnim( ACT_VM_IDLE );
m_bOpen = true;
DoEffect( EFFECT_READY );
#ifdef CLIENT
// Element prediction
m_ElementParameter.InitFromCurrent( 1.0f, 0.2f, INTERP_SPLINE );
m_bOldOpen = true;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::CloseElements( void )
{
if ( m_bOpen == false )
return;
WeaponSound( MELEE_HIT );
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
SendWeaponAnim( ACT_VM_IDLE );
m_bOpen = false;
if ( GetMotorSound() )
{
(CSoundEnvelopeController::GetController()).SoundChangeVolume( GetMotorSound(), 0.0f, 1.0f );
(CSoundEnvelopeController::GetController()).SoundChangePitch( GetMotorSound(), 50, 1.0f );
}
DoEffect( EFFECT_CLOSED );
#ifdef CLIENT
// Element prediction
m_ElementParameter.InitFromCurrent( 0.0f, 0.5f, INTERP_SPLINE );
m_bOldOpen = false;
#endif
}
#define PHYSCANNON_MAX_MASS 500
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CWeaponPhysCannon::GetLoadPercentage( void )
{
float loadWeight = m_grabController.GetLoadWeight();
loadWeight /= physcannon_maxmass.GetFloat();
loadWeight = clamp( loadWeight, 0.0f, 1.0f );
return loadWeight;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CSoundPatch
//-----------------------------------------------------------------------------
CSoundPatch *CWeaponPhysCannon::GetMotorSound( void )
{
if ( m_sndMotor == NULL )
{
CPASAttenuationFilter filter( this );
m_sndMotor = (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_STATIC, "Weapon_PhysCannon.HoldSound", ATTN_NORM );
}
return m_sndMotor;
}
//-----------------------------------------------------------------------------
// Shuts down sounds
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::StopLoopingSounds()
{
if ( m_sndMotor != NULL )
{
(CSoundEnvelopeController::GetController()).SoundDestroy( m_sndMotor );
m_sndMotor = NULL;
}
#ifndef CLIENT_DLL
BaseClass::StopLoopingSounds();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DestroyEffects( void )
{
#ifdef CLIENT_DLL
// Free our beams
m_Beams[0].Release();
m_Beams[1].Release();
m_Beams[2].Release();
#endif
// Stop everything
StopEffects();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::StopEffects( bool stopSound )
{
// Turn off our effect state
DoEffect( EFFECT_NONE );
#ifndef CLIENT_DLL
//Shut off sounds
if ( stopSound && GetMotorSound() != NULL )
{
(CSoundEnvelopeController::GetController()).SoundFadeOut( GetMotorSound(), 0.1f );
}
#endif // !CLIENT_DLL
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::StartEffects( void )
{
#ifdef CLIENT_DLL
// ------------------------------------------
// Core
// ------------------------------------------
if ( m_Parameters[PHYSCANNON_CORE].GetMaterial() == NULL )
{
m_Parameters[PHYSCANNON_CORE].GetScale().Init( 0.0f, 1.0f, 0.1f );
m_Parameters[PHYSCANNON_CORE].GetAlpha().Init( 255.0f, 255.0f, 0.1f );
m_Parameters[PHYSCANNON_CORE].SetAttachment( 1 );
if ( m_Parameters[PHYSCANNON_CORE].SetMaterial( PHYSCANNON_CENTER_GLOW ) == false )
{
// This means the texture was not found
Assert( 0 );
}
}
// ------------------------------------------
// Blast
// ------------------------------------------
if ( m_Parameters[PHYSCANNON_BLAST].GetMaterial() == NULL )
{
m_Parameters[PHYSCANNON_BLAST].GetScale().Init( 0.0f, 1.0f, 0.1f );
m_Parameters[PHYSCANNON_BLAST].GetAlpha().Init( 255.0f, 255.0f, 0.1f );
m_Parameters[PHYSCANNON_BLAST].SetAttachment( 1 );
m_Parameters[PHYSCANNON_BLAST].SetVisible( false );
if ( m_Parameters[PHYSCANNON_BLAST].SetMaterial( PHYSCANNON_BLAST_SPRITE ) == false )
{
// This means the texture was not found
Assert( 0 );
}
}
// ------------------------------------------
// Glows
// ------------------------------------------
const char *attachNamesGlowThirdPerson[NUM_GLOW_SPRITES] =
{
"fork1m",
"fork1t",
"fork2m",
"fork2t",
"fork3m",
"fork3t",
};
const char *attachNamesGlow[NUM_GLOW_SPRITES] =
{
"fork1b",
"fork1m",
"fork1t",
"fork2b",
"fork2m",
"fork2t"
};
//Create the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
if ( m_Parameters[i].GetMaterial() != NULL )
continue;
m_Parameters[i].GetScale().SetAbsolute( 0.05f * SPRITE_SCALE );
m_Parameters[i].GetAlpha().SetAbsolute( 64.0f );
// Different for different views
if ( ShouldDrawUsingViewModel() )
{
m_Parameters[i].SetAttachment( LookupAttachment( attachNamesGlow[i-PHYSCANNON_GLOW1] ) );
}
else
{
m_Parameters[i].SetAttachment( LookupAttachment( attachNamesGlowThirdPerson[i-PHYSCANNON_GLOW1] ) );
}
m_Parameters[i].SetColor( Vector( 255, 128, 0 ) );
if ( m_Parameters[i].SetMaterial( PHYSCANNON_GLOW_SPRITE ) == false )
{
// This means the texture was not found
Assert( 0 );
}
}
// ------------------------------------------
// End caps
// ------------------------------------------
const char *attachNamesEndCap[NUM_ENDCAP_SPRITES] =
{
"fork1t",
"fork2t",
"fork3t"
};
//Create the glow sprites
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
if ( m_Parameters[i].GetMaterial() != NULL )
continue;
m_Parameters[i].GetScale().SetAbsolute( 0.05f * SPRITE_SCALE );
m_Parameters[i].GetAlpha().SetAbsolute( 255.0f );
m_Parameters[i].SetAttachment( LookupAttachment( attachNamesEndCap[i-PHYSCANNON_ENDCAP1] ) );
m_Parameters[i].SetVisible( false );
if ( m_Parameters[i].SetMaterial( PHYSCANNON_ENDCAP_SPRITE ) == false )
{
// This means the texture was not found
Assert( 0 );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Closing effects
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectClosed( void )
{
#ifdef CLIENT_DLL
// Turn off the end-caps
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].SetVisible( false );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Ready effects
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectReady( void )
{
#ifdef CLIENT_DLL
// Special POV case
if ( ShouldDrawUsingViewModel() )
{
//Turn on the center sprite
m_Parameters[PHYSCANNON_CORE].GetScale().InitFromCurrent( 14.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].GetAlpha().InitFromCurrent( 128.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].SetVisible();
}
else
{
//Turn off the center sprite
m_Parameters[PHYSCANNON_CORE].GetScale().InitFromCurrent( 8.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].GetAlpha().InitFromCurrent( 0.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].SetVisible();
}
// Turn on the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].GetScale().InitFromCurrent( 0.4f * SPRITE_SCALE, 0.2f );
m_Parameters[i].GetAlpha().InitFromCurrent( 64.0f, 0.2f );
m_Parameters[i].SetVisible();
}
// Turn on the glow sprites
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].SetVisible( false );
}
#endif
}
//-----------------------------------------------------------------------------
// Holding effects
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectHolding( void )
{
#ifdef CLIENT_DLL
if ( ShouldDrawUsingViewModel() )
{
// Scale up the center sprite
m_Parameters[PHYSCANNON_CORE].GetScale().InitFromCurrent( 16.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].GetAlpha().InitFromCurrent( 255.0f, 0.1f );
m_Parameters[PHYSCANNON_CORE].SetVisible();
// Prepare for scale up
m_Parameters[PHYSCANNON_BLAST].SetVisible( false );
// Turn on the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].GetScale().InitFromCurrent( 0.5f * SPRITE_SCALE, 0.2f );
m_Parameters[i].GetAlpha().InitFromCurrent( 64.0f, 0.2f );
m_Parameters[i].SetVisible();
}
// Turn on the glow sprites
// NOTE: The last glow is left off for first-person
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES-1); i++ )
{
m_Parameters[i].SetVisible();
}
// Create our beams
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
CBaseEntity *pBeamEnt = pOwner->GetViewModel();
// Setup the beams
m_Beams[0].Init( LookupAttachment( "fork1t" ), 1, pBeamEnt, true );
m_Beams[1].Init( LookupAttachment( "fork2t" ), 1, pBeamEnt, true );
// Set them visible
m_Beams[0].SetVisible();
m_Beams[1].SetVisible();
}
else
{
// Scale up the center sprite
m_Parameters[PHYSCANNON_CORE].GetScale().InitFromCurrent( 14.0f, 0.2f );
m_Parameters[PHYSCANNON_CORE].GetAlpha().InitFromCurrent( 255.0f, 0.1f );
m_Parameters[PHYSCANNON_CORE].SetVisible();
// Prepare for scale up
m_Parameters[PHYSCANNON_BLAST].SetVisible( false );
// Turn on the glow sprites
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].GetScale().InitFromCurrent( 0.5f * SPRITE_SCALE, 0.2f );
m_Parameters[i].GetAlpha().InitFromCurrent( 64.0f, 0.2f );
m_Parameters[i].SetVisible();
}
// Turn on the glow sprites
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].SetVisible();
}
// Setup the beams
m_Beams[0].Init( LookupAttachment( "fork1t" ), 1, this, false );
m_Beams[1].Init( LookupAttachment( "fork2t" ), 1, this, false );
m_Beams[2].Init( LookupAttachment( "fork3t" ), 1, this, false );
// Set them visible
m_Beams[0].SetVisible();
m_Beams[1].SetVisible();
m_Beams[2].SetVisible();
}
#endif
}
//-----------------------------------------------------------------------------
// Launch effects
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectLaunch( Vector *pos )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
Vector endPos;
Vector shotDir;
// See if we need to predict this position
if ( pos == NULL )
{
// Hit an entity if we're holding one
if ( m_hAttachedObject )
{
endPos = m_hAttachedObject->WorldSpaceCenter();
shotDir = endPos - pOwner->Weapon_ShootPosition();
VectorNormalize( shotDir );
}
else
{
// Otherwise try and find the right spot
endPos = pOwner->Weapon_ShootPosition();
pOwner->EyeVectors( &shotDir );
trace_t tr;
UTIL_TraceLine( endPos, endPos + ( shotDir * MAX_TRACE_LENGTH ), MASK_SHOT, pOwner, COLLISION_GROUP_NONE, &tr );
endPos = tr.endpos;
shotDir = endPos - pOwner->Weapon_ShootPosition();
VectorNormalize( shotDir );
}
}
else
{
// Use what is supplied
endPos = *pos;
shotDir = ( endPos - pOwner->Weapon_ShootPosition() );
VectorNormalize( shotDir );
}
// End hit
CPVSFilter filter( endPos );
// Don't send this to the owning player, they already had it predicted
if ( IsPredicted() )
{
filter.UsePredictionRules();
}
// Do an impact hit
CEffectData data;
data.m_vOrigin = endPos;
#ifdef CLIENT_DLL
data.m_hEntity = GetRefEHandle();
#else
data.m_nEntIndex = entindex();
#endif
te->DispatchEffect( filter, 0.0, data.m_vOrigin, "PhyscannonImpact", data );
#ifdef CLIENT_DLL
//Turn on the blast sprite and scale
m_Parameters[PHYSCANNON_BLAST].GetScale().Init( 8.0f, 64.0f, 0.1f );
m_Parameters[PHYSCANNON_BLAST].GetAlpha().Init( 255.0f, 0.0f, 0.2f );
m_Parameters[PHYSCANNON_BLAST].SetVisible();
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Shutdown for the weapon when it's holstered
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffectNone( void )
{
#ifdef CLIENT_DLL
//Turn off main glows
m_Parameters[PHYSCANNON_CORE].SetVisible( false );
m_Parameters[PHYSCANNON_BLAST].SetVisible( false );
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
m_Parameters[i].SetVisible( false );
}
// Turn on the glow sprites
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
m_Parameters[i].SetVisible( false );
}
m_Beams[0].SetVisible( false );
m_Beams[1].SetVisible( false );
m_Beams[2].SetVisible( false );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : effectType -
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DoEffect( int effectType, Vector *pos )
{
m_EffectState = effectType;
#ifdef CLIENT_DLL
// Save predicted state
m_nOldEffectState = m_EffectState;
#endif
switch( effectType )
{
case EFFECT_CLOSED:
DoEffectClosed( );
break;
case EFFECT_READY:
DoEffectReady( );
break;
case EFFECT_HOLDING:
DoEffectHolding();
break;
case EFFECT_LAUNCH:
DoEffectLaunch( pos );
break;
default:
case EFFECT_NONE:
DoEffectNone();
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iIndex -
// Output : const char
//-----------------------------------------------------------------------------
const char *CWeaponPhysCannon::GetShootSound( int iIndex ) const
{
return BaseClass::GetShootSound( iIndex );
}
#ifdef CLIENT_DLL
extern void FormatViewModelAttachment( Vector &vOrigin, bool bInverse );
//-----------------------------------------------------------------------------
// Purpose: Gets the complete list of values needed to render an effect from an
// effect parameter
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::GetEffectParameters( EffectType_t effectID, color32 &color, float &scale, IMaterial **pMaterial, Vector &vecAttachment )
{
const float dt = gpGlobals->curtime;
// Get alpha
float alpha = m_Parameters[effectID].GetAlpha().Interp( dt );
// Get scale
scale = m_Parameters[effectID].GetScale().Interp( dt );
// Get material
*pMaterial = (IMaterial *) m_Parameters[effectID].GetMaterial();
// Setup the color
color.r = (int) m_Parameters[effectID].GetColor().x;
color.g = (int) m_Parameters[effectID].GetColor().y;
color.b = (int) m_Parameters[effectID].GetColor().z;
color.a = (int) alpha;
// Setup the attachment
int attachment = m_Parameters[effectID].GetAttachment();
QAngle angles;
// Format for first-person
if ( ShouldDrawUsingViewModel() )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner != NULL )
{
pOwner->GetViewModel()->GetAttachment( attachment, vecAttachment, angles );
::FormatViewModelAttachment( vecAttachment, true );
}
}
else
{
GetAttachment( attachment, vecAttachment, angles );
}
}
//-----------------------------------------------------------------------------
// Purpose: Whether or not an effect is set to display
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::IsEffectVisible( EffectType_t effectID )
{
return m_Parameters[effectID].IsVisible();
}
//-----------------------------------------------------------------------------
// Purpose: Draws the effect sprite, given an effect parameter ID
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DrawEffectSprite( EffectType_t effectID )
{
color32 color;
float scale;
IMaterial *pMaterial;
Vector vecAttachment;
// Don't draw invisible effects
if ( IsEffectVisible( effectID ) == false )
return;
// Get all of our parameters
GetEffectParameters( effectID, color, scale, &pMaterial, vecAttachment );
// Msg( "Scale: %.2f\tAlpha: %.2f\n", scale, alpha );
// Don't render fully translucent objects
if ( color.a <= 0.0f )
return;
// Draw the sprite
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->Bind( pMaterial, this );
DrawSprite( vecAttachment, scale, scale, color );
}
//-----------------------------------------------------------------------------
// Purpose: Render our third-person effects
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::DrawEffects( void )
{
// Draw the core effects
DrawEffectSprite( PHYSCANNON_CORE );
DrawEffectSprite( PHYSCANNON_BLAST );
// Draw the glows
for ( int i = PHYSCANNON_GLOW1; i < (PHYSCANNON_GLOW1+NUM_GLOW_SPRITES); i++ )
{
DrawEffectSprite( (EffectType_t) i );
}
// Draw the endcaps
for ( int i = PHYSCANNON_ENDCAP1; i < (PHYSCANNON_ENDCAP1+NUM_ENDCAP_SPRITES); i++ )
{
DrawEffectSprite( (EffectType_t) i );
}
}
//-----------------------------------------------------------------------------
// Purpose: Third-person function call to render world model
//-----------------------------------------------------------------------------
int CWeaponPhysCannon::DrawModel( int flags )
{
// Only render these on the transparent pass
if ( flags & STUDIO_TRANSPARENCY )
{
DrawEffects();
return 1;
}
// Only do this on the opaque pass
return BaseClass::DrawModel( flags );
}
//-----------------------------------------------------------------------------
// Purpose: First-person function call after viewmodel has been drawn
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::ViewModelDrawn( C_BaseViewModel *pBaseViewModel )
{
// Render our effects
DrawEffects();
// Pass this back up
BaseClass::ViewModelDrawn( pBaseViewModel );
}
//-----------------------------------------------------------------------------
// Purpose: We are always considered transparent
//-----------------------------------------------------------------------------
bool CWeaponPhysCannon::IsTransparent( void )
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponPhysCannon::NotifyShouldTransmit( ShouldTransmitState_t state )
{
BaseClass::NotifyShouldTransmit(state);
if ( state == SHOULDTRANSMIT_END )
{
DoEffect( EFFECT_NONE );
}
}
#endif
//-----------------------------------------------------------------------------
// EXTERNAL API
//-----------------------------------------------------------------------------
void PhysCannonForceDrop( CBaseCombatWeapon *pActiveWeapon, CBaseEntity *pOnlyIfHoldingThis )
{
CWeaponPhysCannon *pCannon = dynamic_cast<CWeaponPhysCannon *>(pActiveWeapon);
if ( pCannon )
{
if ( pOnlyIfHoldingThis )
{
pCannon->DropIfEntityHeld( pOnlyIfHoldingThis );
}
else
{
pCannon->ForceDrop();
}
}
}
bool PlayerPickupControllerIsHoldingEntity( CBaseEntity *pPickupControllerEntity, CBaseEntity *pHeldEntity )
{
CPlayerPickupController *pController = dynamic_cast<CPlayerPickupController *>(pPickupControllerEntity);
return pController ? pController->IsHoldingEntity( pHeldEntity ) : false;
}
float PhysCannonGetHeldObjectMass( CBaseCombatWeapon *pActiveWeapon, IPhysicsObject *pHeldObject )
{
float mass = 0.0f;
CWeaponPhysCannon *pCannon = dynamic_cast<CWeaponPhysCannon *>(pActiveWeapon);
if ( pCannon )
{
CGrabController &grab = pCannon->GetGrabController();
mass = grab.GetSavedMass( pHeldObject );
}
return mass;
}
CBaseEntity *PhysCannonGetHeldEntity( CBaseCombatWeapon *pActiveWeapon )
{
CWeaponPhysCannon *pCannon = dynamic_cast<CWeaponPhysCannon *>(pActiveWeapon);
if ( pCannon )
{
CGrabController &grab = pCannon->GetGrabController();
return grab.GetAttached();
}
return NULL;
}
float PlayerPickupGetHeldObjectMass( CBaseEntity *pPickupControllerEntity, IPhysicsObject *pHeldObject )
{
float mass = 0.0f;
CPlayerPickupController *pController = dynamic_cast<CPlayerPickupController *>(pPickupControllerEntity);
if ( pController )
{
CGrabController &grab = pController->GetGrabController();
mass = grab.GetSavedMass( pHeldObject );
}
return mass;
}
#ifdef CLIENT_DLL
extern void FX_GaussExplosion( const Vector &pos, const Vector &dir, int type );
void CallbackPhyscannonImpact( const CEffectData &data )
{
C_BaseEntity *pEnt = data.GetEntity();
if ( pEnt == NULL )
return;
Vector vecAttachment;
QAngle vecAngles;
C_BaseCombatWeapon *pWeapon = dynamic_cast<C_BaseCombatWeapon *>(pEnt);
if ( pWeapon == NULL )
return;
pWeapon->GetAttachment( 1, vecAttachment, vecAngles );
Vector dir = ( data.m_vOrigin - vecAttachment );
VectorNormalize( dir );
// Do special first-person fix-up
if ( pWeapon->GetOwner() == CBasePlayer::GetLocalPlayer() )
{
// Translate the attachment entity to the viewmodel
C_BasePlayer *pPlayer = dynamic_cast<C_BasePlayer *>(pWeapon->GetOwner());
if ( pPlayer )
{
pEnt = pPlayer->GetViewModel();
}
// Format attachment for first-person view!
::FormatViewModelAttachment( vecAttachment, true );
// Explosions at the impact point
FX_GaussExplosion( data.m_vOrigin, -dir, 0 );
// Draw a beam
BeamInfo_t beamInfo;
beamInfo.m_pStartEnt = pEnt;
beamInfo.m_nStartAttachment = 1;
beamInfo.m_pEndEnt = NULL;
beamInfo.m_nEndAttachment = -1;
beamInfo.m_vecStart = vec3_origin;
beamInfo.m_vecEnd = data.m_vOrigin;
beamInfo.m_pszModelName = PHYSCANNON_BEAM_SPRITE;
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.1f;
beamInfo.m_flWidth = 12.0f;
beamInfo.m_flEndWidth = 4.0f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 0;
beamInfo.m_flBrightness = 255.0;
beamInfo.m_flSpeed = 0.0f;
beamInfo.m_nStartFrame = 0.0;
beamInfo.m_flFrameRate = 30.0;
beamInfo.m_flRed = 255.0;
beamInfo.m_flGreen = 255.0;
beamInfo.m_flBlue = 255.0;
beamInfo.m_nSegments = 16;
beamInfo.m_bRenderable = true;
beamInfo.m_nFlags = FBEAM_ONLYNOISEONCE;
beams->CreateBeamEntPoint( beamInfo );
}
else
{
// Explosion at the starting point
FX_GaussExplosion( vecAttachment, dir, 0 );
}
}
DECLARE_CLIENT_EFFECT( "PhyscannonImpact", CallbackPhyscannonImpact );
#endif