First version of the SOurce SDK 2013

1 files changed, 3685 insertions, 0 deletions

diff --git a/mp/src/game/shared/hl2mp/weapon_physcannon.cpp b/mp/src/game/shared/hl2mp/weapon_physcannon.cpp
new file mode 100644
index 00000000..97245b14
--- /dev/null
+++ b/mp/src/game/shared/hl2mp/weapon_physcannon.cpp
@@ -0,0 +1,3685 @@
+//========= 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