tf2/tf2_src/game/shared/tfc/weapon_tfc_crowbar.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include "cbase.h"
#include "util.h"
#include "weapon_tfc_crowbar.h"
#include "decals.h"

#if defined( CLIENT_DLL )
	#include "c_tfc_player.h"
#else
	#include "tfc_player.h"
#endif


#define	KNIFE_BODYHIT_VOLUME 128
#define	KNIFE_WALLHIT_VOLUME 512


static ConVar tfc_crowbar_damage_first( "tfc_crowbar_damage_first", "25", 0, "First crowbar hit damage." );
static ConVar tfc_crowbar_damage_next( "tfc_crowbar_damage_next", "12.5", 0, "Crowbar hit damage after first hit." );
		

static Vector head_hull_mins( -16, -16, -18 );
static Vector head_hull_maxs( 16, 16, 18 );


// ----------------------------------------------------------------------------- //
// CTFCCrowbar tables.
// ----------------------------------------------------------------------------- //

IMPLEMENT_NETWORKCLASS_ALIASED( TFCCrowbar, DT_WeaponCrowbar )

BEGIN_NETWORK_TABLE( CTFCCrowbar, DT_WeaponCrowbar )
END_NETWORK_TABLE()

BEGIN_PREDICTION_DATA( CTFCCrowbar )
END_PREDICTION_DATA()

LINK_ENTITY_TO_CLASS( weapon_crowbar, CTFCCrowbar );
PRECACHE_WEAPON_REGISTER( weapon_crowbar );

#ifndef CLIENT_DLL

	BEGIN_DATADESC( CTFCCrowbar )
		DEFINE_FUNCTION( Smack )
	END_DATADESC()

#endif

// ----------------------------------------------------------------------------- //
// CTFCCrowbar implementation.
// ----------------------------------------------------------------------------- //

CTFCCrowbar::CTFCCrowbar()
{
}


bool CTFCCrowbar::HasPrimaryAmmo()
{
	return true;
}


bool CTFCCrowbar::CanBeSelected()
{
	return true;
}

void CTFCCrowbar::Precache()
{
	BaseClass::Precache();
}

void CTFCCrowbar::Spawn()
{
	Precache();

	m_iClip1 = -1;
	BaseClass::Spawn();
}


bool CTFCCrowbar::Deploy()
{
	CPASAttenuationFilter filter( this );
	filter.UsePredictionRules();
	EmitSound( filter, entindex(), "Weapon_Crowbar.Deploy" );

	return BaseClass::Deploy();
}

void CTFCCrowbar::Holster( int skiplocal )
{
	GetPlayerOwner()->m_flNextAttack = gpGlobals->curtime + 0.5;
}

void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity )
{
	int			i, j, k;
	float		distance;
	Vector minmaxs[2] = {mins, maxs};
	trace_t tmpTrace;
	Vector		vecHullEnd = tr.endpos;
	Vector		vecEnd;

	distance = 1e6f;

	vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
	UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
	if ( tmpTrace.fraction < 1.0 )
	{
		tr = tmpTrace;
		return;
	}

	for ( i = 0; i < 2; i++ )
	{
		for ( j = 0; j < 2; j++ )
		{
			for ( k = 0; k < 2; k++ )
			{
				vecEnd.x = vecHullEnd.x + minmaxs[i][0];
				vecEnd.y = vecHullEnd.y + minmaxs[j][1];
				vecEnd.z = vecHullEnd.z + minmaxs[k][2];

				UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
				if ( tmpTrace.fraction < 1.0 )
				{
					float thisDistance = (tmpTrace.endpos - vecSrc).Length();
					if ( thisDistance < distance )
					{
						tr = tmpTrace;
						distance = thisDistance;
					}
				}
			}
		}
	}
}


void CTFCCrowbar::ItemPostFrame()
{
	// Store this off so we can detect if it's our first swing or not later on.
	m_flStoredPrimaryAttack = m_flNextPrimaryAttack;
	BaseClass::ItemPostFrame();
}


void CTFCCrowbar::PrimaryAttack()
{
	CTFCPlayer *pPlayer = GetPlayerOwner();

	Vector vForward;
	AngleVectors( pPlayer->EyeAngles(), &vForward );
	Vector vecSrc	= pPlayer->Weapon_ShootPosition();
	Vector vecEnd	= vecSrc + vForward * 32;

	trace_t tr;
	UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );

	if ( tr.fraction >= 1.0 )
	{
		UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
		if ( tr.fraction < 1.0 )
		{
			// Calculate the point of intersection of the line (or hull) and the object we hit
			// This is and approximation of the "best" intersection
			CBaseEntity *pHit = tr.m_pEnt;
			if ( !pHit || pHit->IsBSPModel() )
				FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, pPlayer );
			vecEnd = tr.endpos;	// This is the point on the actual surface (the hull could have hit space)
		}
	}

	bool bDidHit = tr.fraction < 1.0f;

#ifndef CLIENT_DLL
	bool bFirstSwing = (gpGlobals->curtime - m_flStoredPrimaryAttack) >= 1;
#endif

	pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN );

	m_flTimeWeaponIdle = gpGlobals->curtime + 2;
	m_flNextPrimaryAttack = gpGlobals->curtime + 0.4f;

	if ( bDidHit )
	{
		SendWeaponAnim( ACT_VM_HITCENTER );
	}
	else
	{
		// Allow for there only being hit activities.
		if ( !SendWeaponAnim( ACT_VM_MISSCENTER ) )
			SendWeaponAnim( ACT_VM_HITCENTER );

		// play wiff or swish sound
		WeaponSound( MELEE_MISS );
	}

	bool bPlayImpactEffect = false;
	
#ifndef CLIENT_DLL

	if ( bDidHit )
	{
		CBaseEntity *pEntity = tr.m_pEnt;
		
		ClearMultiDamage();

		float flDamage = 0;
		bool bDoEffects = true;
		AxeHit( pEntity, bFirstSwing, tr, &flDamage, &bDoEffects );
		if ( flDamage != 0 )
		{
			CTakeDamageInfo info( pPlayer, pPlayer, flDamage, DMG_CLUB | DMG_NEVERGIB );

			CalculateMeleeDamageForce( &info, vForward, tr.endpos, 1.0f/flDamage );
			pEntity->DispatchTraceAttack( info, vForward, &tr ); 
			ApplyMultiDamage();
		}

		if ( bDoEffects )
		{
			if ( pEntity && pEntity->IsPlayer() )
			{
				WeaponSound( MELEE_HIT );

				if ( pEntity->IsAlive() )
					bPlayImpactEffect = true; // no blood effect on dead bodies
			}
			else
			{
				bPlayImpactEffect = true; // always show impact effects on world objects
			}
		}
		else
		{
			bDoEffects = false;
		}
	}


#endif

	if ( bPlayImpactEffect )
	{
		// delay the decal a bit
		m_trHit = tr;
		
		// Store the ent in an EHANDLE, just in case it goes away by the time we get into our think function.
		m_pTraceHitEnt = tr.m_pEnt; 

		SetThink( &CTFCCrowbar::Smack );
		SetNextThink( gpGlobals->curtime + 0.2f );
	}
}


void CTFCCrowbar::Smack()
{
	m_trHit.m_pEnt = m_pTraceHitEnt;
	UTIL_ImpactTrace( &m_trHit, DMG_CLUB );
	
	surfacedata_t *psurf = physprops->GetSurfaceData( m_trHit.surface.surfaceProps );
	if ( psurf->game.material != CHAR_TEX_FLESH && psurf->game.material != CHAR_TEX_BLOODYFLESH )
		WeaponSound( MELEE_HIT_WORLD );
}



void CTFCCrowbar::WeaponIdle()
{
	//ResetEmptySound();

	CTFCPlayer *pPlayer = GetPlayerOwner();

	if (m_flTimeWeaponIdle > gpGlobals->curtime)
		return;

	m_flTimeWeaponIdle = gpGlobals->curtime + 20;

	// only idle if the slid isn't back
	SendWeaponAnim( ACT_VM_IDLE );
}


bool CTFCCrowbar::CanDrop()
{
	return false;
}


TFCWeaponID CTFCCrowbar::GetWeaponID( void ) const
{ 
	return WEAPON_CROWBAR;
}


#ifdef CLIENT_DLL
	
	// ------------------------------------------------------------------------------------------------ //
	// ------------------------------------------------------------------------------------------------ //
	// CLIENT DLL SPECIFIC CODE
	// ------------------------------------------------------------------------------------------------ //
	// ------------------------------------------------------------------------------------------------ //


#else

	// ------------------------------------------------------------------------------------------------ //
	// ------------------------------------------------------------------------------------------------ //
	// GAME DLL SPECIFIC CODE
	// ------------------------------------------------------------------------------------------------ //
	// ------------------------------------------------------------------------------------------------ //

	void CTFCCrowbar::AxeHit( CBaseEntity *pHit, bool bFirstSwing, trace_t &tr, float *flDamage, bool *bDoEffects )
	{
		if ( bFirstSwing )
			*flDamage = tfc_crowbar_damage_first.GetFloat();
		else
			*flDamage = tfc_crowbar_damage_next.GetFloat();
	}

#endif