Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1417 lines
36 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "in_buttons.h"
#include "takedamageinfo.h"
#include "weapon_dodbase.h"
#include "ammodef.h"
#include "dod_gamerules.h"
#ifdef CLIENT_DLL
extern IVModelInfoClient* modelinfo;
#else
extern IVModelInfo* modelinfo;
#include "ilagcompensationmanager.h"
#endif
#if defined( CLIENT_DLL )
#include "vgui/ISurface.h"
#include "vgui_controls/Controls.h"
#include "c_dod_player.h"
#include "hud_crosshair.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#else
#include "dod_player.h"
#endif
#include "effect_dispatch_data.h"
// ----------------------------------------------------------------------------- //
// Global functions.
// ----------------------------------------------------------------------------- //
bool IsAmmoType( int iAmmoType, const char *pAmmoName )
{
return GetAmmoDef()->Index( pAmmoName ) == iAmmoType;
}
//--------------------------------------------------------------------------------------------------------
//
// Given a weapon ID, return its alias
//
const char *WeaponIDToAlias( int id )
{
if ( (id >= WEAPON_MAX) || (id < 0) )
return NULL;
return s_WeaponAliasInfo[id];
}
// ----------------------------------------------------------------------------- //
// CWeaponDODBase tables.
// ----------------------------------------------------------------------------- //
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDODBase, DT_WeaponDODBase )
BEGIN_NETWORK_TABLE( CWeaponDODBase, DT_WeaponDODBase )
#ifdef CLIENT_DLL
RecvPropInt( RECVINFO(m_iReloadModelIndex) ),
RecvPropVector( RECVINFO( m_vInitialDropVelocity ) ),
RecvPropTime( RECVINFO( m_flSmackTime ) )
#else
SendPropVector( SENDINFO( m_vInitialDropVelocity ),
20, // nbits
0, // flags
-3000, // low value
3000 // high value
),
SendPropModelIndex( SENDINFO(m_iReloadModelIndex) ),
SendPropTime( SENDINFO( m_flSmackTime ) )
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( weapon_dod_base, CWeaponDODBase );
#ifdef GAME_DLL
BEGIN_DATADESC( CWeaponDODBase )
DEFINE_FUNCTION( FallThink ),
DEFINE_FUNCTION( Die ),
DEFINE_FUNCTION( Smack )
END_DATADESC()
#else
BEGIN_PREDICTION_DATA( CWeaponDODBase )
DEFINE_PRED_FIELD( m_flSmackTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), // for rifle melee attacks
DEFINE_FIELD( m_bInAttack, FIELD_BOOLEAN )
END_PREDICTION_DATA()
#endif
Vector head_hull_mins( -16, -16, -18 );
Vector head_hull_maxs( 16, 16, 18 );
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;
CTraceFilterSimple filter( pEntity, COLLISION_GROUP_NONE );
distance = 1e6f;
vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, &filter, &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, &filter, &tmpTrace );
if ( tmpTrace.fraction < 1.0 )
{
float thisDistance = (tmpTrace.endpos - vecSrc).Length();
if ( thisDistance < distance )
{
tr = tmpTrace;
distance = thisDistance;
}
}
}
}
}
}
// ----------------------------------------------------------------------------- //
// CWeaponDODBase implementation.
// ----------------------------------------------------------------------------- //
CWeaponDODBase::CWeaponDODBase()
{
SetPredictionEligible( true );
m_bInAttack = false;
m_iAltFireHint = 0;
AddSolidFlags( FSOLID_TRIGGER ); // Nothing collides with these but it gets touches.
m_flNextPrimaryAttack = 0;
}
bool CWeaponDODBase::IsPredicted() const
{
return true;
}
bool CWeaponDODBase::PlayEmptySound()
{
CPASAttenuationFilter filter( this );
filter.UsePredictionRules();
EmitSound( filter, entindex(), "Default.ClipEmpty_Rifle" );
return false;
}
CBasePlayer* CWeaponDODBase::GetPlayerOwner() const
{
return dynamic_cast< CBasePlayer* >( GetOwner() );
}
CDODPlayer* CWeaponDODBase::GetDODPlayerOwner() const
{
return dynamic_cast< CDODPlayer* >( GetOwner() );
}
bool CWeaponDODBase::SendWeaponAnim( int iActivity )
{
return BaseClass::SendWeaponAnim( iActivity );
}
bool CWeaponDODBase::CanAttack( void )
{
CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
if ( pPlayer )
{
return pPlayer->CanAttack();
}
return false;
}
bool CWeaponDODBase::ShouldAutoReload( void )
{
CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
if ( pPlayer )
{
return pPlayer->ShouldAutoReload();
}
return false;
}
void CWeaponDODBase::ItemPostFrame()
{
if ( m_flSmackTime > 0 && gpGlobals->curtime > m_flSmackTime )
{
Smack();
m_flSmackTime = -1;
}
CBasePlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
#ifdef _DEBUG
CDODGameRules *mp = DODGameRules();
#endif
assert( mp );
if ((m_bInReload) && (pPlayer->m_flNextAttack <= gpGlobals->curtime))
{
// complete the reload.
int j = MIN( GetMaxClip1() - m_iClip1, pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) );
// Add them to the clip
m_iClip1 += j;
pPlayer->RemoveAmmo( j, m_iPrimaryAmmoType );
m_bInReload = false;
FinishReload();
}
if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
{
if ( m_iClip2 != -1 && !pPlayer->GetAmmoCount( GetSecondaryAmmoType() ) )
{
m_bFireOnEmpty = TRUE;
}
SecondaryAttack();
pPlayer->m_nButtons &= ~IN_ATTACK2;
}
else if ((pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime ) && !m_bInAttack )
{
if ( (m_iClip1 == 0/* && pszAmmo1()*/) || (GetMaxClip1() == -1 && !pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) ) )
{
m_bFireOnEmpty = TRUE;
}
if( CanAttack() )
PrimaryAttack();
}
else if ( pPlayer->m_nButtons & IN_RELOAD && GetMaxClip1() != WEAPON_NOCLIP && !m_bInReload && m_flNextPrimaryAttack < gpGlobals->curtime)
{
// reload when reload is pressed, or if no buttons are down and weapon is empty.
Reload();
}
else if ( !(pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) ) )
{
// no fire buttons down
m_bFireOnEmpty = false;
m_bInAttack = false; //reset semi-auto
if ( !IsUseable() && m_flNextPrimaryAttack < gpGlobals->curtime )
{
// Intentionally blank -- used to switch weapons here
}
else if( ShouldAutoReload() )
{
// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
{
Reload();
return;
}
}
WeaponIdle( );
return;
}
}
void CWeaponDODBase::WeaponIdle()
{
if (m_flTimeWeaponIdle > gpGlobals->curtime)
return;
SendWeaponAnim( GetIdleActivity() );
m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
}
Activity CWeaponDODBase::GetIdleActivity( void )
{
return ACT_VM_IDLE;
}
const CDODWeaponInfo &CWeaponDODBase::GetDODWpnData() const
{
const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
const CDODWeaponInfo *pDODInfo;
#ifdef _DEBUG
pDODInfo = dynamic_cast< const CDODWeaponInfo* >( pWeaponInfo );
Assert( pDODInfo );
#else
pDODInfo = static_cast< const CDODWeaponInfo* >( pWeaponInfo );
#endif
return *pDODInfo;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CWeaponDODBase::GetViewModel( int /*viewmodelindex = 0 -- this is ignored in the base class here*/ ) const
{
if ( GetPlayerOwner() == NULL )
{
return BaseClass::GetViewModel();
}
return GetWpnData().szViewModel;
}
void CWeaponDODBase::Precache( void )
{
// precache base first, it loads weapon scripts
BaseClass::Precache();
PrecacheScriptSound( "Default.ClipEmpty_Rifle" );
PrecacheParticleSystem( "muzzle_pistols" );
PrecacheParticleSystem( "muzzle_fullyautomatic" );
PrecacheParticleSystem( "muzzle_rifles" );
PrecacheParticleSystem( "muzzle_rockets" );
PrecacheParticleSystem( "muzzle_mg42" );
PrecacheParticleSystem( "view_muzzle_pistols" );
PrecacheParticleSystem( "view_muzzle_fullyautomatic" );
PrecacheParticleSystem( "view_muzzle_rifles" );
PrecacheParticleSystem( "view_muzzle_rockets" );
PrecacheParticleSystem( "view_muzzle_mg42" );
const CDODWeaponInfo &info = GetDODWpnData();
int iWpnNameLen = Q_strlen(info.m_szReloadModel);
#ifdef DEBUG
// Make sure that if we declare an alt weapon, that we have criteria to show it
// and vice-versa
//Assert( ((info.m_iAltWpnCriteria & (ALTWPN_CRITERIA_RELOADING | ALTWPN_CRITERIA_FIRING)) > 0 ) ==
// (iWpnNameLen > 0) );
#endif
if( iWpnNameLen > 0 )
m_iReloadModelIndex = CBaseEntity::PrecacheModel( info.m_szReloadModel );
}
bool CWeaponDODBase::DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt )
{
CBasePlayer *pOwner = GetPlayerOwner();
if ( !pOwner )
{
return false;
}
pOwner->SetAnimationExtension( szAnimExt );
SetViewModel();
SendWeaponAnim( iActivity );
pOwner->SetNextAttack( gpGlobals->curtime + SequenceDuration() );
m_flNextPrimaryAttack = MAX( m_flNextPrimaryAttack, gpGlobals->curtime );
m_flNextSecondaryAttack = gpGlobals->curtime;
SetWeaponVisible( true );
SetWeaponModelIndex( szWeaponModel );
CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex );
Assert( vm );
if( vm )
{
//set sleeves to proper team
switch( pOwner->GetTeamNumber() )
{
case TEAM_ALLIES:
vm->m_nSkin = SLEEVE_ALLIES;
break;
case TEAM_AXIS:
vm->m_nSkin = SLEEVE_AXIS;
break;
default:
Assert( !"TEAM_UNASSIGNED or spectator getting a view model assigned" );
break;
}
}
return true;
}
void CWeaponDODBase::SetWeaponModelIndex( const char *pName )
{
m_iWorldModelIndex = modelinfo->GetModelIndex( pName );
}
bool CWeaponDODBase::CanBeSelected( void )
{
if ( !VisibleInWeaponSelection() )
return false;
return true;
}
bool CWeaponDODBase::CanDeploy( void )
{
return BaseClass::CanDeploy();
}
bool CWeaponDODBase::CanHolster( void )
{
return BaseClass::CanHolster();
}
void CWeaponDODBase::Drop( const Vector &vecVelocity )
{
#ifndef CLIENT_DLL
if ( m_iAltFireHint )
{
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
{
pPlayer->StopHintTimer( m_iAltFireHint );
}
}
#endif
// cancel any reload in progress
m_bInReload = false;
m_flSmackTime = -1;
m_vInitialDropVelocity = vecVelocity;
BaseClass::Drop( m_vInitialDropVelocity );
}
bool CWeaponDODBase::Holster( CBaseCombatWeapon *pSwitchingTo )
{
#ifndef CLIENT_DLL
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
{
pPlayer->SetFOV( pPlayer, 0 ); // reset the default FOV.
if ( m_iAltFireHint )
{
pPlayer->StopHintTimer( m_iAltFireHint );
}
}
#endif
m_bInReload = false;
m_flSmackTime = -1;
return BaseClass::Holster( pSwitchingTo );
}
bool CWeaponDODBase::Deploy()
{
#ifndef CLIENT_DLL
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
{
pPlayer->SetFOV( pPlayer, 0 );
if ( m_iAltFireHint )
{
pPlayer->StartHintTimer( m_iAltFireHint );
}
}
#endif
return BaseClass::Deploy();
}
#ifdef CLIENT_DLL
void CWeaponDODBase::PostDataUpdate( DataUpdateType_t updateType )
{
// We need to do this before the C_BaseAnimating code starts to drive
// clientside animation sequences on this model, which will be using bad sequences for the world model.
int iDesiredModelIndex = 0;
C_BasePlayer *localplayer = C_BasePlayer::GetLocalPlayer();
if ( localplayer && localplayer == GetOwner() && !C_BasePlayer::ShouldDrawLocalPlayer() ) // FIXME: use localplayer->ShouldDrawThisPlayer() instead.
{
iDesiredModelIndex = m_iViewModelIndex;
}
else
{
iDesiredModelIndex = GetWorldModelIndex();
// Our world models never animate
SetSequence( 0 );
}
if ( GetModelIndex() != iDesiredModelIndex )
{
SetModelIndex( iDesiredModelIndex );
}
BaseClass::PostDataUpdate( updateType );
}
void CWeaponDODBase::OnDataChanged( DataUpdateType_t type )
{
if ( m_iState == WEAPON_NOT_CARRIED && m_iOldState != WEAPON_NOT_CARRIED )
{
// we are being notified of the weapon being dropped
// add an interpolation history so the movement is smoother
// Now stick our initial velocity into the interpolation history
CInterpolatedVar< Vector > &interpolator = GetOriginInterpolator();
interpolator.ClearHistory();
float changeTime = GetLastChangeTime( LATCH_SIMULATION_VAR );
// Add a sample 1 second back.
Vector vCurOrigin = GetLocalOrigin() - m_vInitialDropVelocity;
interpolator.AddToHead( changeTime - 1.0, &vCurOrigin, false );
// Add the current sample.
vCurOrigin = GetLocalOrigin();
interpolator.AddToHead( changeTime, &vCurOrigin, false );
Vector estVel;
EstimateAbsVelocity( estVel );
/*Msg( "estimated velocity ( %.1f %.1f %.1f ) initial velocity ( %.1f %.1f %.1f )\n",
estVel.x,
estVel.y,
estVel.z,
m_vInitialDropVelocity.m_Value.x,
m_vInitialDropVelocity.m_Value.y,
m_vInitialDropVelocity.m_Value.z );*/
OnWeaponDropped();
}
BaseClass::OnDataChanged( type );
if ( GetPredictable() && !ShouldPredict() )
ShutdownPredictable();
}
int CWeaponDODBase::GetWorldModelIndex( void )
{
if( m_bUseAltWeaponModel && GetOwner() != NULL )
return m_iReloadModelIndex;
else
return m_iWorldModelIndex;
}
bool CWeaponDODBase::ShouldPredict()
{
if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
return true;
return BaseClass::ShouldPredict();
}
void CWeaponDODBase::ProcessMuzzleFlashEvent()
{
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
pPlayer->ProcessMuzzleFlashEvent();
BaseClass::ProcessMuzzleFlashEvent();
}
#else
//-----------------------------------------------------------------------------
// Purpose: Get the accuracy derived from weapon and player, and return it
//-----------------------------------------------------------------------------
const Vector& CWeaponDODBase::GetBulletSpread()
{
static Vector cone = VECTOR_CONE_8DEGREES;
return cone;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponDODBase::ItemBusyFrame()
{
if( ShouldAutoReload() && !m_bInReload )
{
// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
{
Reload();
}
}
BaseClass::ItemBusyFrame();
}
//-----------------------------------------------------------------------------
// Purpose: Match the anim speed to the weapon speed while crouching
//-----------------------------------------------------------------------------
float CWeaponDODBase::GetDefaultAnimSpeed()
{
return 1.0;
}
bool CWeaponDODBase::ShouldRemoveOnRoundRestart()
{
if ( GetPlayerOwner() )
return false;
else
return true;
}
//=========================================================
// Materialize - make a CWeaponDODBase visible and tangible
//=========================================================
void CWeaponDODBase::Materialize()
{
if ( IsEffectActive( EF_NODRAW ) )
{
RemoveEffects( EF_NODRAW );
DoMuzzleFlash();
}
AddSolidFlags( FSOLID_TRIGGER );
SetThink (&CWeaponDODBase::SUB_Remove);
SetNextThink( gpGlobals->curtime + 1 );
}
//=========================================================
// AttemptToMaterialize - the item is trying to rematerialize,
// should it do so now or wait longer?
//=========================================================
void CWeaponDODBase::AttemptToMaterialize()
{
float time = g_pGameRules->FlWeaponTryRespawn( this );
if ( time == 0 )
{
Materialize();
return;
}
SetNextThink( gpGlobals->curtime + time );
}
//=========================================================
// CheckRespawn - a player is taking this weapon, should
// it respawn?
//=========================================================
void CWeaponDODBase::CheckRespawn()
{
//GOOSEMAN : Do not respawn weapons!
return;
}
//=========================================================
// Respawn- this item is already in the world, but it is
// invisible and intangible. Make it visible and tangible.
//=========================================================
CBaseEntity* CWeaponDODBase::Respawn()
{
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
// will decide when to make the weapon visible and touchable.
CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetAbsAngles(), GetOwner() );
if ( pNewWeapon )
{
pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
pNewWeapon->SetTouch( NULL );// no touch
pNewWeapon->SetThink( &CWeaponDODBase::AttemptToMaterialize );
UTIL_DropToFloor( this, MASK_SOLID );
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
// but when it should respawn is based on conditions belonging to the weapon that was taken.
pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
}
else
{
Msg( "Respawn failed to create %s!\n", GetClassname() );
}
return pNewWeapon;
}
bool CWeaponDODBase::Reload()
{
return BaseClass::Reload();
}
void CWeaponDODBase::Spawn()
{
BaseClass::Spawn();
// Set this here to allow players to shoot dropped weapons
SetCollisionGroup( COLLISION_GROUP_WEAPON );
SetExtraAmmoCount(0); //Start with no additional ammo
CollisionProp()->UseTriggerBounds( true, 10.0f );
}
void CWeaponDODBase::SetDieThink( bool bDie )
{
if( bDie )
SetContextThink( &CWeaponDODBase::Die, gpGlobals->curtime + 45.0f, "DieContext" );
else
SetContextThink( NULL, gpGlobals->curtime, "DieContext" );
}
void CWeaponDODBase::Die( void )
{
UTIL_Remove( this );
}
#endif
void CWeaponDODBase::OnPickedUp( CBaseCombatCharacter *pNewOwner )
{
BaseClass::OnPickedUp( pNewOwner );
#if !defined( CLIENT_DLL )
SetDieThink( false );
#endif
}
bool CWeaponDODBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
return false;
// If I don't have any spare ammo, I can't reload
if ( pOwner->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
return false;
bool bReload = false;
// If you don't have clips, then don't try to reload them.
if ( UsesClipsForAmmo1() )
{
// need to reload primary clip?
int primary = min(iClipSize1 - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType));
if ( primary != 0 )
{
bReload = true;
}
}
if ( UsesClipsForAmmo2() )
{
// need to reload secondary clip?
int secondary = min(iClipSize2 - m_iClip2, pOwner->GetAmmoCount(m_iSecondaryAmmoType));
if ( secondary != 0 )
{
bReload = true;
}
}
if ( !bReload )
return false;
CDODPlayer *pPlayer = GetDODPlayerOwner();
if ( pPlayer )
{
#ifdef CLIENT_DLL
PlayWorldReloadSound( pPlayer );
#else
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
#endif
}
SendWeaponAnim( iActivity );
// Play the player's reload animation
if ( pOwner->IsPlayer() )
{
( ( CBasePlayer * )pOwner)->SetAnimation( PLAYER_RELOAD );
}
float flSequenceEndTime = gpGlobals->curtime + SequenceDuration();
pOwner->SetNextAttack( flSequenceEndTime );
m_flNextPrimaryAttack = m_flNextSecondaryAttack = flSequenceEndTime;
m_bInReload = true;
return true;
}
#ifdef CLIENT_DLL
void CWeaponDODBase::PlayWorldReloadSound( CDODPlayer *pPlayer )
{
Assert( pPlayer );
const char *shootsound = GetShootSound( RELOAD );
if ( !shootsound || !shootsound[0] )
return;
CSoundParameters params;
if ( !GetParametersForSound( shootsound, params, NULL ) )
return;
// Play weapon sound from the owner
CPASAttenuationFilter filter( pPlayer, params.soundlevel );
filter.RemoveRecipient( pPlayer ); // no local player, that is done in the model
EmitSound( filter, pPlayer->entindex(), shootsound, NULL, 0.0 );
}
#endif
bool CWeaponDODBase::IsUseable()
{
CBasePlayer *pPlayer = GetPlayerOwner();
if ( Clip1() <= 0 )
{
if ( pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 && GetMaxClip1() != -1 )
{
// clip is empty (or nonexistant) and the player has no more ammo of this type.
return false;
}
}
return true;
}
#ifndef CLIENT_DLL
ConVar dod_meleeattackforcescale( "dod_meleeattackforcescale", "8.0", FCVAR_CHEAT | FCVAR_GAMEDLL );
#endif
void CWeaponDODBase::RifleButt( void )
{
//MeleeAttack( 60, MELEE_DMG_BUTTSTOCK | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.9f );
}
void CWeaponDODBase::Bayonet( void )
{
//MeleeAttack( 60, MELEE_DMG_BAYONET | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.9f );
}
void CWeaponDODBase::Punch( void )
{
MeleeAttack( 60, MELEE_DMG_FIST | MELEE_DMG_SECONDARYATTACK, 0.2f, 0.4f );
}
//--------------------------------------------
// iDamageAmount - how much damage to give
// iDamageType - DMG_ bits
// flDmgDelay - delay between attack and the giving of damage, usually timed to animation
// flAttackDelay - time until we can next attack
//--------------------------------------------
CBaseEntity *CWeaponDODBase::MeleeAttack( int iDamageAmount, int iDamageType, float flDmgDelay, float flAttackDelay )
{
if ( !CanAttack() )
return NULL;
CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
#if !defined (CLIENT_DLL)
// Move other players back to history positions based on local player's lag
lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
#endif
Vector vForward, vRight, vUp;
AngleVectors( pPlayer->EyeAngles(), &vForward, &vRight, &vUp );
Vector vecSrc = pPlayer->Weapon_ShootPosition();
Vector vecEnd = vecSrc + vForward * 48;
CTraceFilterSimple filter( pPlayer, COLLISION_GROUP_NONE );
int iTraceMask = MASK_SOLID | CONTENTS_HITBOX | CONTENTS_DEBRIS;
trace_t tr;
UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &filter, &tr );
const float rayExtension = 40.0f;
UTIL_ClipTraceToPlayers( vecSrc, vecEnd + vForward * rayExtension, iTraceMask, &filter, &tr );
// If the exact forward trace did not hit, try a larger swept box
if ( tr.fraction >= 1.0 )
{
Vector head_hull_mins( -16, -16, -18 );
Vector head_hull_maxs( 16, 16, 18 );
UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, &filter, &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)
// Make sure it is in front of us
Vector vecToEnd = vecEnd - vecSrc;
VectorNormalize( vecToEnd );
// if zero length, always hit
if ( vecToEnd.Length() > 0 )
{
float dot = DotProduct( vForward, vecToEnd );
// sanity that our hit is within range
if ( abs(dot) < 0.95 )
{
// fake that we actually missed
tr.fraction = 1.0;
}
}
}
}
WeaponSound( MELEE_MISS );
bool bDidHit = ( tr.fraction < 1.0f );
if ( bDidHit ) //if the swing hit
{
// 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;
m_iSmackDamage = iDamageAmount;
m_iSmackDamageType = iDamageType;
m_flSmackTime = gpGlobals->curtime + flDmgDelay;
}
SendWeaponAnim( GetMeleeActivity() );
// player animation
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_SECONDARY_ATTACK );
m_flNextPrimaryAttack = gpGlobals->curtime + flAttackDelay;
m_flNextSecondaryAttack = gpGlobals->curtime + flAttackDelay;
m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
#ifndef CLIENT_DLL
IGameEvent * event = gameeventmanager->CreateEvent( "dod_stats_weapon_attack" );
if ( event )
{
event->SetInt( "attacker", pPlayer->GetUserID() );
event->SetInt( "weapon", GetAltWeaponID() );
gameeventmanager->FireEvent( event );
}
lagcompensation->FinishLagCompensation( pPlayer );
#endif //CLIENT_DLL
return tr.m_pEnt;
}
//Think function to delay the impact decal until the animation is finished playing
void CWeaponDODBase::Smack()
{
Assert( GetPlayerOwner() );
if ( !GetPlayerOwner() )
return;
CDODPlayer *pPlayer = ToDODPlayer( GetPlayerOwner() );
if ( !pPlayer )
return;
// Check that we are still facing the victim
Vector vForward, vRight, vUp;
AngleVectors( pPlayer->EyeAngles(), &vForward, &vRight, &vUp );
Vector vecSrc = pPlayer->Weapon_ShootPosition();
Vector vecEnd = vecSrc + vForward * 48;
CTraceFilterSimple filter( pPlayer, COLLISION_GROUP_NONE );
int iTraceMask = MASK_SOLID | CONTENTS_HITBOX | CONTENTS_DEBRIS;
trace_t tr;
UTIL_TraceLine( vecSrc, vecEnd, iTraceMask, &filter, &tr );
const float rayExtension = 40.0f;
UTIL_ClipTraceToPlayers( vecSrc, vecEnd + vForward * rayExtension, iTraceMask, &filter, &tr );
if ( tr.fraction >= 1.0 )
{
Vector head_hull_mins( -16, -16, -18 );
Vector head_hull_maxs( 16, 16, 18 );
UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, &filter, &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)
}
}
m_trHit = tr;
if ( !m_trHit.m_pEnt || (m_trHit.surface.flags & SURF_SKY) )
return;
if ( m_trHit.fraction == 1.0 )
return;
CPASAttenuationFilter attenuationFilter( this );
attenuationFilter.UsePredictionRules();
if( m_trHit.m_pEnt->IsPlayer() )
{
if ( m_iSmackDamageType & MELEE_DMG_STRONGATTACK )
WeaponSound( SPECIAL1 );
else
WeaponSound( MELEE_HIT );
}
else
WeaponSound( MELEE_HIT_WORLD );
int iDamageType = DMG_CLUB | DMG_NEVERGIB;
#ifndef CLIENT_DLL
//if they hit the bounding box, just assume a chest hit
if( m_trHit.hitgroup == HITGROUP_GENERIC )
m_trHit.hitgroup = HITGROUP_CHEST;
float flDamage = (float)m_iSmackDamage;
CTakeDamageInfo info( pPlayer, pPlayer, flDamage, iDamageType );
if ( m_iSmackDamageType & MELEE_DMG_SECONDARYATTACK )
info.SetDamageCustom( MELEE_DMG_SECONDARYATTACK );
float flScale = (1.0f / flDamage) * dod_meleeattackforcescale.GetFloat();
Vector vecForceDir = vForward;
CalculateMeleeDamageForce( &info, vecForceDir, m_trHit.endpos, flScale );
Assert( m_trHit.m_pEnt != GetPlayerOwner() );
m_trHit.m_pEnt->DispatchTraceAttack( info, vForward, &m_trHit );
ApplyMultiDamage();
#endif
// We've gotten minidumps where this happened.
if ( !GetPlayerOwner() )
return;
CEffectData data;
data.m_vOrigin = m_trHit.endpos;
data.m_vStart = m_trHit.startpos;
data.m_nSurfaceProp = m_trHit.surface.surfaceProps;
data.m_nHitBox = m_trHit.hitbox;
#ifdef CLIENT_DLL
data.m_hEntity = m_trHit.m_pEnt->GetRefEHandle();
#else
data.m_nEntIndex = m_trHit.m_pEnt->entindex();
#endif
CPASFilter effectfilter( data.m_vOrigin );
#ifndef CLIENT_DLL
effectfilter.RemoveRecipient( GetPlayerOwner() );
#endif
data.m_vAngles = GetPlayerOwner()->GetAbsAngles();
data.m_fFlags = 0x1; //IMPACT_NODECAL;
data.m_nDamageType = iDamageType;
bool bHitPlayer = m_trHit.m_pEnt && m_trHit.m_pEnt->IsPlayer();
// don't do any impacts if we hit a teammate and ff is off
if ( bHitPlayer &&
m_trHit.m_pEnt->GetTeamNumber() == GetPlayerOwner()->GetTeamNumber() &&
!friendlyfire.GetBool() )
return;
if ( bHitPlayer )
{
te->DispatchEffect( effectfilter, 0.0, data.m_vOrigin, "Impact", data );
}
else if ( m_iSmackDamageType & MELEE_DMG_EDGE )
{
data.m_nDamageType = DMG_SLASH;
te->DispatchEffect( effectfilter, 0.0, data.m_vOrigin, "KnifeSlash", data );
}
}
#if defined( CLIENT_DLL )
float g_lateralBob = 0;
float g_verticalBob = 0;
static ConVar cl_bobcycle( "cl_bobcycle","0.8" );
static ConVar cl_bob( "cl_bob","0.002" );
static ConVar cl_bobup( "cl_bobup","0.5" );
// Register these cvars if needed for easy tweaking
static ConVar v_iyaw_cycle( "v_iyaw_cycle", "2"/*, FCVAR_UNREGISTERED*/ );
static ConVar v_iroll_cycle( "v_iroll_cycle", "0.5"/*, FCVAR_UNREGISTERED*/ );
static ConVar v_ipitch_cycle( "v_ipitch_cycle", "1"/*, FCVAR_UNREGISTERED*/ );
static ConVar v_iyaw_level( "v_iyaw_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
static ConVar v_iroll_level( "v_iroll_level", "0.1"/*, FCVAR_UNREGISTERED*/ );
static ConVar v_ipitch_level( "v_ipitch_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CWeaponDODBase::CalcViewmodelBob( void )
{
static float bobtime;
static float lastbobtime;
static float lastspeed;
float cycle;
CBasePlayer *player = ToBasePlayer( GetOwner() );
//Assert( player );
//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
if ( ( !gpGlobals->frametime ) || ( player == NULL ) )
{
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;// just use old value
}
//Find the speed of the player
float speed = player->GetLocalVelocity().Length2D();
float flmaxSpeedDelta = MAX( 0, (gpGlobals->curtime - lastbobtime) * 320.0f );
// don't allow too big speed changes
speed = clamp( speed, lastspeed-flmaxSpeedDelta, lastspeed+flmaxSpeedDelta );
speed = clamp( speed, -320, 320 );
lastspeed = speed;
//FIXME: This maximum speed value must come from the server.
// MaxSpeed() is not sufficient for dealing with sprinting - jdw
float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
bobtime += ( gpGlobals->curtime - lastbobtime ) * bob_offset;
lastbobtime = gpGlobals->curtime;
//Calculate the vertical bob
cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
cycle /= cl_bobcycle.GetFloat();
if ( cycle < cl_bobup.GetFloat() )
{
cycle = M_PI * cycle / cl_bobup.GetFloat();
}
else
{
cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
}
g_verticalBob = speed*0.005f;
g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
g_verticalBob = clamp( g_verticalBob, -7.0f, 4.0f );
//Calculate the lateral bob
cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat()*2)*cl_bobcycle.GetFloat()*2;
cycle /= cl_bobcycle.GetFloat()*2;
if ( cycle < cl_bobup.GetFloat() )
{
cycle = M_PI * cycle / cl_bobup.GetFloat();
}
else
{
cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
}
g_lateralBob = speed*0.005f;
g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
g_lateralBob = clamp( g_lateralBob, -7.0f, 4.0f );
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// &angles -
// viewmodelindex -
//-----------------------------------------------------------------------------
void CWeaponDODBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
{
Vector forward, right;
AngleVectors( angles, &forward, &right, NULL );
CalcViewmodelBob();
// Apply bob, but scaled down to 40%
VectorMA( origin, g_verticalBob * 0.4f, forward, origin );
// Z bob a bit more
origin[2] += g_verticalBob * 0.1f;
// bob the angles
angles[ ROLL ] += g_verticalBob * 0.5f;
angles[ PITCH ] -= g_verticalBob * 0.4f;
angles[ YAW ] -= g_lateralBob * 0.3f;
// VectorMA( origin, g_lateralBob * 0.2f, right, origin );
}
#include "c_te_effect_dispatch.h"
#define NUM_MUZZLE_FLASH_TYPES 4
bool CWeaponDODBase::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
{
if( event == 5001 )
{
if ( ShouldDrawMuzzleFlash() )
{
Assert( GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() );
const char *pszMuzzleFlashEffect;
switch( GetDODWpnData().m_iMuzzleFlashType )
{
case DOD_MUZZLEFLASH_PISTOL:
pszMuzzleFlashEffect = "view_muzzle_pistols";
break;
case DOD_MUZZLEFLASH_AUTO:
pszMuzzleFlashEffect = "view_muzzle_fullyautomatic";
break;
case DOD_MUZZLEFLASH_RIFLE:
pszMuzzleFlashEffect = "view_muzzle_rifles";
break;
case DOD_MUZZLEFLASH_MG:
pszMuzzleFlashEffect = "view_muzzle_miniguns";
break;
case DOD_MUZZLEFLASH_ROCKET:
pszMuzzleFlashEffect = "view_muzzle_rockets";
break;
case DOD_MUZZLEFLASH_MG42:
pszMuzzleFlashEffect = "view_muzzle_mg42";
break;
default:
pszMuzzleFlashEffect = NULL;
break;
}
if ( pszMuzzleFlashEffect )
{
pViewModel->ParticleProp()->Create( pszMuzzleFlashEffect, PATTACH_POINT_FOLLOW, 1 );
}
}
return true;
}
else if( event == 6002 )
{
CEffectData data;
data.m_nHitBox = atoi( options );
data.m_hEntity = GetPlayerOwner() ? GetPlayerOwner()->GetRefEHandle() : INVALID_EHANDLE_INDEX;
pViewModel->GetAttachment( 2, data.m_vOrigin, data.m_vAngles );
DispatchEffect( "DOD_EjectBrass", data );
return true;
}
return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
}
bool CWeaponDODBase::ShouldAutoEjectBrass( void )
{
// Don't eject brass if further than N units from the local player
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pLocalPlayer )
return true;
float flMaxDistSqr = 250;
flMaxDistSqr *= flMaxDistSqr;
float flDistSqr = pLocalPlayer->EyePosition().DistToSqr( GetAbsOrigin() );
return ( flDistSqr < flMaxDistSqr );
}
bool CWeaponDODBase::GetEjectBrassShellType( void )
{
return 1;
}
void CWeaponDODBase::SetUseAltModel( bool bUseAltModel )
{
m_bUseAltWeaponModel = bUseAltModel;
}
void CWeaponDODBase::CheckForAltWeapon( int iCurrentState )
{
int iCriteria = GetDODWpnData().m_iAltWpnCriteria;
bool bUseAltModel = false;
if( ( iCriteria & iCurrentState ) != 0 )
bUseAltModel = true;
SetUseAltModel( bUseAltModel );
}
Vector CWeaponDODBase::GetDesiredViewModelOffset( C_DODPlayer *pOwner )
{
Vector viewOffset = pOwner->GetViewOffset();
float flPercent = ( viewOffset.z - VEC_PRONE_VIEW_SCALED( pOwner ).z ) / ( VEC_VIEW_SCALED( pOwner ).z - VEC_PRONE_VIEW_SCALED( pOwner ).z );
return ( flPercent * GetDODWpnData().m_vecViewNormalOffset +
( 1.0 - flPercent ) * GetDODWpnData().m_vecViewProneOffset );
}
bool CWeaponDODBase::ShouldDraw( void )
{
if ( GetModel() == NULL )
{
// XXX(johns): Removed, doesn't seem to be the proper spot for this warning given that weapons can call
// ShouldDraw before their properties are filled.
// C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
// Warning( "BADNESS! Tell Matt that the weapon '%s' tried to draw with a null model ( %d, %d, %s ) \n",
// GetDODWpnData().szClassName,
// m_iWorldModelIndex.Get(), m_iReloadModelIndex.Get(), m_bUseAltWeaponModel ? "alt" : "not alt" );
return false;
}
return BaseClass::ShouldDraw();
}
#else
void CWeaponDODBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
{
}
float CWeaponDODBase::CalcViewmodelBob( void )
{
return 0.0f;
}
void CWeaponDODBase::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( CanDrop() == false )
return;
CDODPlayer *pPlayer = ToDODPlayer( pActivator );
if ( pPlayer )
{
pPlayer->PickUpWeapon( this );
}
}
#endif