From 39ed87570bdb2f86969d4be821c94b722dc71179 Mon Sep 17 00:00:00 2001 From: Joe Ludwig Date: Wed, 26 Jun 2013 15:22:04 -0700 Subject: First version of the SOurce SDK 2013 --- mp/src/game/shared/basecombatweapon_shared.cpp | 2805 ++++++++++++++++++++++++ 1 file changed, 2805 insertions(+) create mode 100644 mp/src/game/shared/basecombatweapon_shared.cpp (limited to 'mp/src/game/shared/basecombatweapon_shared.cpp') diff --git a/mp/src/game/shared/basecombatweapon_shared.cpp b/mp/src/game/shared/basecombatweapon_shared.cpp new file mode 100644 index 00000000..28c98bf5 --- /dev/null +++ b/mp/src/game/shared/basecombatweapon_shared.cpp @@ -0,0 +1,2805 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// +#include "cbase.h" +#include "in_buttons.h" +#include "engine/IEngineSound.h" +#include "ammodef.h" +#include "SoundEmitterSystem/isoundemittersystembase.h" +#include "physics_saverestore.h" +#include "datacache/imdlcache.h" +#include "activitylist.h" + +// NVNT start extra includes +#include "haptics/haptic_utils.h" +#ifdef CLIENT_DLL + #include "prediction.h" +#endif +// NVNT end extra includes + +#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL ) +#include "tf_shareddefs.h" +#endif + +#if !defined( CLIENT_DLL ) + +// Game DLL Headers +#include "soundent.h" +#include "eventqueue.h" +#include "fmtstr.h" +#include "gameweaponmanager.h" + +#ifdef HL2MP + #include "hl2mp_gamerules.h" +#endif + +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +// The minimum time a hud hint for a weapon should be on screen. If we switch away before +// this, then teh hud hint counter will be deremented so the hint will be shown again, as +// if it had never been seen. The total display time for a hud hint is specified in client +// script HudAnimations.txt (which I can't read here). +#define MIN_HUDHINT_DISPLAY_TIME 7.0f + +#define HIDEWEAPON_THINK_CONTEXT "BaseCombatWeapon_HideThink" + +extern bool UTIL_ItemCanBeTouchedByPlayer( CBaseEntity *pItem, CBasePlayer *pPlayer ); + +#if defined ( TF_CLIENT_DLL ) || defined ( TF_DLL ) +#ifdef _DEBUG +ConVar tf_weapon_criticals_force_random( "tf_weapon_criticals_force_random", "0", FCVAR_REPLICATED | FCVAR_CHEAT ); +#endif // _DEBUG +ConVar tf_weapon_criticals_bucket_cap( "tf_weapon_criticals_bucket_cap", "1000.0", FCVAR_REPLICATED | FCVAR_CHEAT ); +ConVar tf_weapon_criticals_bucket_bottom( "tf_weapon_criticals_bucket_bottom", "-250.0", FCVAR_REPLICATED | FCVAR_CHEAT ); +ConVar tf_weapon_criticals_bucket_default( "tf_weapon_criticals_bucket_default", "300.0", FCVAR_REPLICATED | FCVAR_CHEAT ); +#endif // TF + +CBaseCombatWeapon::CBaseCombatWeapon() +{ + // Constructor must call this + // CONSTRUCT_PREDICTABLE( CBaseCombatWeapon ); + + // Some default values. There should be set in the particular weapon classes + m_fMinRange1 = 65; + m_fMinRange2 = 65; + m_fMaxRange1 = 1024; + m_fMaxRange2 = 1024; + + m_bReloadsSingly = false; + + // Defaults to zero + m_nViewModelIndex = 0; + + m_bFlipViewModel = false; + +#if defined( CLIENT_DLL ) + m_iState = m_iOldState = WEAPON_NOT_CARRIED; + m_iClip1 = -1; + m_iClip2 = -1; + m_iPrimaryAmmoType = -1; + m_iSecondaryAmmoType = -1; +#endif + +#if !defined( CLIENT_DLL ) + m_pConstraint = NULL; + OnBaseCombatWeaponCreated( this ); +#endif + + m_hWeaponFileInfo = GetInvalidWeaponInfoHandle(); + +#if defined( TF_DLL ) + UseClientSideAnimation(); +#endif + +#if defined ( TF_CLIENT_DLL ) || defined ( TF_DLL ) + m_flCritTokenBucket = tf_weapon_criticals_bucket_default.GetFloat(); + m_nCritChecks = 1; + m_nCritSeedRequests = 0; +#endif // TF +} + +//----------------------------------------------------------------------------- +// Purpose: Destructor +//----------------------------------------------------------------------------- +CBaseCombatWeapon::~CBaseCombatWeapon( void ) +{ +#if !defined( CLIENT_DLL ) + //Remove our constraint, if we have one + if ( m_pConstraint != NULL ) + { + physenv->DestroyConstraint( m_pConstraint ); + m_pConstraint = NULL; + } + OnBaseCombatWeaponDestroyed( this ); +#endif +} + +void CBaseCombatWeapon::Activate( void ) +{ + BaseClass::Activate(); + +#ifndef CLIENT_DLL + if ( GetOwnerEntity() ) + return; + + if ( g_pGameRules->IsAllowedToSpawn( this ) == false ) + { + UTIL_Remove( this ); + return; + } +#endif + +} +void CBaseCombatWeapon::GiveDefaultAmmo( void ) +{ + // If I use clips, set my clips to the default + if ( UsesClipsForAmmo1() ) + { + m_iClip1 = AutoFiresFullClip() ? 0 : GetDefaultClip1(); + } + else + { + SetPrimaryAmmoCount( GetDefaultClip1() ); + m_iClip1 = WEAPON_NOCLIP; + } + if ( UsesClipsForAmmo2() ) + { + m_iClip2 = GetDefaultClip2(); + } + else + { + SetSecondaryAmmoCount( GetDefaultClip2() ); + m_iClip2 = WEAPON_NOCLIP; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Set mode to world model and start falling to the ground +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::Spawn( void ) +{ + Precache(); + + BaseClass::Spawn(); + + SetSolid( SOLID_BBOX ); + m_flNextEmptySoundTime = 0.0f; + + // Weapons won't show up in trace calls if they are being carried... + RemoveEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID ); + + m_iState = WEAPON_NOT_CARRIED; + // Assume + m_nViewModelIndex = 0; + + GiveDefaultAmmo(); + + if ( GetWorldModel() ) + { + SetModel( GetWorldModel() ); + } + +#if !defined( CLIENT_DLL ) + if( IsX360() ) + { + AddEffects( EF_ITEM_BLINK ); + } + + FallInit(); + SetCollisionGroup( COLLISION_GROUP_WEAPON ); + m_takedamage = DAMAGE_EVENTS_ONLY; + + SetBlocksLOS( false ); + + // Default to non-removeable, because we don't want the + // game_weapon_manager entity to remove weapons that have + // been hand-placed by level designers. We only want to remove + // weapons that have been dropped by NPC's. + SetRemoveable( false ); +#endif + + // Bloat the box for player pickup + CollisionProp()->UseTriggerBounds( true, 36 ); + + // Use more efficient bbox culling on the client. Otherwise, it'll setup bones for most + // characters even when they're not in the frustum. + AddEffects( EF_BONEMERGE_FASTCULL ); + + m_iReloadHudHintCount = 0; + m_iAltFireHudHintCount = 0; + m_flHudHintMinDisplayTime = 0; +} + +//----------------------------------------------------------------------------- +// Purpose: get this game's encryption key for decoding weapon kv files +// Output : virtual const unsigned char +//----------------------------------------------------------------------------- +const unsigned char *CBaseCombatWeapon::GetEncryptionKey( void ) +{ + return g_pGameRules->GetEncryptionKey(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::Precache( void ) +{ +#if defined( CLIENT_DLL ) + Assert( Q_strlen( GetClassname() ) > 0 ); + // Msg( "Client got %s\n", GetClassname() ); +#endif + m_iPrimaryAmmoType = m_iSecondaryAmmoType = -1; + + // Add this weapon to the weapon registry, and get our index into it + // Get weapon data from script file + if ( ReadWeaponDataFromFileForSlot( filesystem, GetClassname(), &m_hWeaponFileInfo, GetEncryptionKey() ) ) + { + // Get the ammo indexes for the ammo's specified in the data file + if ( GetWpnData().szAmmo1[0] ) + { + m_iPrimaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo1 ); + if (m_iPrimaryAmmoType == -1) + { + Msg("ERROR: Weapon (%s) using undefined primary ammo type (%s)\n",GetClassname(), GetWpnData().szAmmo1); + } + #if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL ) + // Ammo override + int iModUseMetalOverride = 0; + CALL_ATTRIB_HOOK_INT( iModUseMetalOverride, mod_use_metal_ammo_type ); + if ( iModUseMetalOverride ) + { + m_iPrimaryAmmoType = (int)TF_AMMO_METAL; + } +#endif + } + if ( GetWpnData().szAmmo2[0] ) + { + m_iSecondaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo2 ); + if (m_iSecondaryAmmoType == -1) + { + Msg("ERROR: Weapon (%s) using undefined secondary ammo type (%s)\n",GetClassname(),GetWpnData().szAmmo2); + } + + } +#if defined( CLIENT_DLL ) + gWR.LoadWeaponSprites( GetWeaponFileInfoHandle() ); +#endif + // Precache models (preload to avoid hitch) + m_iViewModelIndex = 0; + m_iWorldModelIndex = 0; + if ( GetViewModel() && GetViewModel()[0] ) + { + m_iViewModelIndex = CBaseEntity::PrecacheModel( GetViewModel() ); + } + if ( GetWorldModel() && GetWorldModel()[0] ) + { + m_iWorldModelIndex = CBaseEntity::PrecacheModel( GetWorldModel() ); + } + + // Precache sounds, too + for ( int i = 0; i < NUM_SHOOT_SOUND_TYPES; ++i ) + { + const char *shootsound = GetShootSound( i ); + if ( shootsound && shootsound[0] ) + { + CBaseEntity::PrecacheScriptSound( shootsound ); + } + } + } + else + { + // Couldn't read data file, remove myself + Warning( "Error reading weapon data file for: %s\n", GetClassname() ); + // Remove( ); //don't remove, this gets released soon! + } +} + +//----------------------------------------------------------------------------- +// Purpose: Get my data in the file weapon info array +//----------------------------------------------------------------------------- +const FileWeaponInfo_t &CBaseCombatWeapon::GetWpnData( void ) const +{ + return *GetFileWeaponInfoFromHandle( m_hWeaponFileInfo ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetViewModel( int /*viewmodelindex = 0 -- this is ignored in the base class here*/ ) const +{ + return GetWpnData().szViewModel; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetWorldModel( void ) const +{ + return GetWpnData().szWorldModel; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetAnimPrefix( void ) const +{ + return GetWpnData().szAnimationPrefix; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : char const +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetPrintName( void ) const +{ + return GetWpnData().szPrintName; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetMaxClip1( void ) const +{ +#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL ) + int iModMaxClipOverride = 0; + CALL_ATTRIB_HOOK_INT( iModMaxClipOverride, mod_max_primary_clip_override ); + if ( iModMaxClipOverride != 0 ) + return iModMaxClipOverride; +#endif + + return GetWpnData().iMaxClip1; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetMaxClip2( void ) const +{ + return GetWpnData().iMaxClip2; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetDefaultClip1( void ) const +{ + return GetWpnData().iDefaultClip1; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetDefaultClip2( void ) const +{ + return GetWpnData().iDefaultClip2; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::UsesClipsForAmmo1( void ) const +{ + return ( GetMaxClip1() != WEAPON_NOCLIP ); +} + +bool CBaseCombatWeapon::IsMeleeWeapon() const +{ + return GetWpnData().m_bMeleeWeapon; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::UsesClipsForAmmo2( void ) const +{ + return ( GetMaxClip2() != WEAPON_NOCLIP ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetWeight( void ) const +{ + return GetWpnData().iWeight; +} + +//----------------------------------------------------------------------------- +// Purpose: Whether this weapon can be autoswitched to when the player runs out +// of ammo in their current weapon or they pick this weapon up. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::AllowsAutoSwitchTo( void ) const +{ + return GetWpnData().bAutoSwitchTo; +} + +//----------------------------------------------------------------------------- +// Purpose: Whether this weapon can be autoswitched away from when the player +// runs out of ammo in this weapon or picks up another weapon or ammo. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::AllowsAutoSwitchFrom( void ) const +{ + return GetWpnData().bAutoSwitchFrom; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetWeaponFlags( void ) const +{ + return GetWpnData().iFlags; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetSlot( void ) const +{ + return GetWpnData().iSlot; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetPosition( void ) const +{ + return GetWpnData().iPosition; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetName( void ) const +{ + return GetWpnData().szClassName; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteActive( void ) const +{ + return GetWpnData().iconActive; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteInactive( void ) const +{ + return GetWpnData().iconInactive; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteAmmo( void ) const +{ + return GetWpnData().iconAmmo; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteAmmo2( void ) const +{ + return GetWpnData().iconAmmo2; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteCrosshair( void ) const +{ + return GetWpnData().iconCrosshair; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteAutoaim( void ) const +{ + return GetWpnData().iconAutoaim; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteZoomedCrosshair( void ) const +{ + return GetWpnData().iconZoomedCrosshair; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CHudTexture const *CBaseCombatWeapon::GetSpriteZoomedAutoaim( void ) const +{ + return GetWpnData().iconZoomedAutoaim; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CBaseCombatWeapon::GetShootSound( int iIndex ) const +{ + return GetWpnData().aShootSounds[ iIndex ]; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetRumbleEffect() const +{ + return GetWpnData().iRumbleEffect; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CBaseCombatCharacter *CBaseCombatWeapon::GetOwner() const +{ + return ToBaseCombatCharacter( m_hOwner.Get() ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : BaseCombatCharacter - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SetOwner( CBaseCombatCharacter *owner ) +{ + if ( !owner ) + { +#ifndef CLIENT_DLL + // Make sure the weapon updates its state when it's removed from the player + // We have to force an active state change, because it's being dropped and won't call UpdateClientData() + int iOldState = m_iState; + m_iState = WEAPON_NOT_CARRIED; + OnActiveStateChanged( iOldState ); +#endif + + // make sure we clear out our HideThink if we have one pending + SetContextThink( NULL, 0, HIDEWEAPON_THINK_CONTEXT ); + } + + m_hOwner = owner; + +#ifndef CLIENT_DLL + DispatchUpdateTransmitState(); +#else + UpdateVisibility(); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: Return false if this weapon won't let the player switch away from it +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::IsAllowedToSwitch( void ) +{ + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if this weapon can be selected via the weapon selection +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::CanBeSelected( void ) +{ + if ( !VisibleInWeaponSelection() ) + return false; + + return HasAmmo(); +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if this weapon has some ammo +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::HasAmmo( void ) +{ + // Weapons with no ammo types can always be selected + if ( m_iPrimaryAmmoType == -1 && m_iSecondaryAmmoType == -1 ) + return true; + if ( GetWeaponFlags() & ITEM_FLAG_SELECTONEMPTY ) + return true; + + CBasePlayer *player = ToBasePlayer( GetOwner() ); + if ( !player ) + return false; + return ( m_iClip1 > 0 || player->GetAmmoCount( m_iPrimaryAmmoType ) || m_iClip2 > 0 || player->GetAmmoCount( m_iSecondaryAmmoType ) ); +} + +//----------------------------------------------------------------------------- +// Purpose: Return true if this weapon should be seen, and hence be selectable, in the weapon selection +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::VisibleInWeaponSelection( void ) +{ + return true; +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::HasWeaponIdleTimeElapsed( void ) +{ + if ( gpGlobals->curtime > m_flTimeWeaponIdle ) + return true; + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : time - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SetWeaponIdleTime( float time ) +{ + m_flTimeWeaponIdle = time; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : float +//----------------------------------------------------------------------------- +float CBaseCombatWeapon::GetWeaponIdleTime( void ) +{ + return m_flTimeWeaponIdle; +} + +//----------------------------------------------------------------------------- +// Purpose: Drop/throw the weapon with the given velocity. +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::Drop( const Vector &vecVelocity ) +{ +#if !defined( CLIENT_DLL ) + + // Once somebody drops a gun, it's fair game for removal when/if + // a game_weapon_manager does a cleanup on surplus weapons in the + // world. + SetRemoveable( true ); + WeaponManager_AmmoMod( this ); + + //If it was dropped then there's no need to respawn it. + AddSpawnFlags( SF_NORESPAWN ); + + StopAnimation(); + StopFollowingEntity( ); + SetMoveType( MOVETYPE_FLYGRAVITY ); + // clear follow stuff, setup for collision + SetGravity(1.0); + m_iState = WEAPON_NOT_CARRIED; + RemoveEffects( EF_NODRAW ); + FallInit(); + SetGroundEntity( NULL ); + SetThink( &CBaseCombatWeapon::SetPickupTouch ); + SetTouch(NULL); + + if( hl2_episodic.GetBool() ) + { + RemoveSpawnFlags( SF_WEAPON_NO_PLAYER_PICKUP ); + } + + IPhysicsObject *pObj = VPhysicsGetObject(); + if ( pObj != NULL ) + { + AngularImpulse angImp( 200, 200, 200 ); + pObj->AddVelocity( &vecVelocity, &angImp ); + } + else + { + SetAbsVelocity( vecVelocity ); + } + + CBaseEntity *pOwner = GetOwnerEntity(); + + SetNextThink( gpGlobals->curtime + 1.0f ); + SetOwnerEntity( NULL ); + SetOwner( NULL ); + + // If we're not allowing to spawn due to the gamerules, + // remove myself when I'm dropped by an NPC. + if ( pOwner && pOwner->IsNPC() ) + { + if ( g_pGameRules->IsAllowedToSpawn( this ) == false ) + { + UTIL_Remove( this ); + return; + } + } +#endif +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pPicker - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::OnPickedUp( CBaseCombatCharacter *pNewOwner ) +{ +#if !defined( CLIENT_DLL ) + RemoveEffects( EF_ITEM_BLINK ); + + if( pNewOwner->IsPlayer() ) + { + m_OnPlayerPickup.FireOutput(pNewOwner, this); + + // Play the pickup sound for 1st-person observers + CRecipientFilter filter; + for ( int i=1; i <= gpGlobals->maxClients; ++i ) + { + CBasePlayer *player = UTIL_PlayerByIndex(i); + if ( player && !player->IsAlive() && player->GetObserverMode() == OBS_MODE_IN_EYE ) + { + filter.AddRecipient( player ); + } + } + if ( filter.GetRecipientCount() ) + { + CBaseEntity::EmitSound( filter, pNewOwner->entindex(), "Player.PickupWeapon" ); + } + + // Robin: We don't want to delete weapons the player has picked up, so + // clear the name of the weapon. This prevents wildcards that are meant + // to find NPCs finding weapons dropped by the NPCs as well. + SetName( NULL_STRING ); + } + else + { + m_OnNPCPickup.FireOutput(pNewOwner, this); + } + +#ifdef HL2MP + HL2MPRules()->RemoveLevelDesignerPlacedObject( this ); +#endif + + // Someone picked me up, so make it so that I can't be removed. + SetRemoveable( false ); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : &vecTracerSrc - +// &tr - +// iTracerType - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ) +{ + CBaseEntity *pOwner = GetOwner(); + + if ( pOwner == NULL ) + { + BaseClass::MakeTracer( vecTracerSrc, tr, iTracerType ); + return; + } + + const char *pszTracerName = GetTracerType(); + + Vector vNewSrc = vecTracerSrc; + int iEntIndex = pOwner->entindex(); + + if ( g_pGameRules->IsMultiplayer() ) + { + iEntIndex = entindex(); + } + + int iAttachment = GetTracerAttachment(); + + switch ( iTracerType ) + { + case TRACER_LINE: + UTIL_Tracer( vNewSrc, tr.endpos, iEntIndex, iAttachment, 0.0f, true, pszTracerName ); + break; + + case TRACER_LINE_AND_WHIZ: + UTIL_Tracer( vNewSrc, tr.endpos, iEntIndex, iAttachment, 0.0f, true, pszTracerName ); + break; + } +} + +void CBaseCombatWeapon::GiveTo( CBaseEntity *pOther ) +{ + DefaultTouch( pOther ); +} + +//----------------------------------------------------------------------------- +// Purpose: Default Touch function for player picking up a weapon (not AI) +// Input : pOther - the entity that touched me +// Output : +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::DefaultTouch( CBaseEntity *pOther ) +{ +#if !defined( CLIENT_DLL ) + // Can't pick up dissolving weapons + if ( IsDissolving() ) + return; + + // if it's not a player, ignore + CBasePlayer *pPlayer = ToBasePlayer(pOther); + if ( !pPlayer ) + return; + + if( UTIL_ItemCanBeTouchedByPlayer(this, pPlayer) ) + { + // This makes sure the player could potentially take the object + // before firing the cache interaction output. That doesn't mean + // the player WILL end up taking the object, but cache interactions + // are fired as soon as you prove you have found the object, not + // when you finally acquire it. + m_OnCacheInteraction.FireOutput( pOther, this ); + } + + if( HasSpawnFlags(SF_WEAPON_NO_PLAYER_PICKUP) ) + return; + + if (pPlayer->BumpWeapon(this)) + { + OnPickedUp( pPlayer ); + } +#endif +} + +//--------------------------------------------------------- +// It's OK for base classes to override this completely +// without calling up. (sjb) +//--------------------------------------------------------- +bool CBaseCombatWeapon::ShouldDisplayAltFireHUDHint() +{ + if( m_iAltFireHudHintCount >= WEAPON_RELOAD_HUD_HINT_COUNT ) + return false; + + if( UsesSecondaryAmmo() && HasSecondaryAmmo() ) + { + return true; + } + + if( !UsesSecondaryAmmo() && HasPrimaryAmmo() ) + { + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::DisplayAltFireHudHint() +{ +#if !defined( CLIENT_DLL ) + CFmtStr hint; + hint.sprintf( "#valve_hint_alt_%s", GetClassname() ); + UTIL_HudHintText( GetOwner(), hint.Access() ); + m_iAltFireHudHintCount++; + m_bAltFireHudHintDisplayed = true; + m_flHudHintMinDisplayTime = gpGlobals->curtime + MIN_HUDHINT_DISPLAY_TIME; +#endif//CLIENT_DLL +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::RescindAltFireHudHint() +{ +#if !defined( CLIENT_DLL ) + Assert(m_bAltFireHudHintDisplayed); + + UTIL_HudHintText( GetOwner(), "" ); + --m_iAltFireHudHintCount; + m_bAltFireHudHintDisplayed = false; +#endif//CLIENT_DLL +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::ShouldDisplayReloadHUDHint() +{ + if( m_iReloadHudHintCount >= WEAPON_RELOAD_HUD_HINT_COUNT ) + return false; + + CBaseCombatCharacter *pOwner = GetOwner(); + + if( pOwner != NULL && pOwner->IsPlayer() && UsesClipsForAmmo1() && m_iClip1 < (GetMaxClip1() / 2) ) + { + // I'm owned by a player, I use clips, I have less then half a clip loaded. Now, does the player have more ammo? + if ( pOwner ) + { + if ( pOwner->GetAmmoCount( m_iPrimaryAmmoType ) > 0 ) + return true; + } + } + + return false; +} +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::DisplayReloadHudHint() +{ +#if !defined( CLIENT_DLL ) + UTIL_HudHintText( GetOwner(), "valve_hint_reload" ); + m_iReloadHudHintCount++; + m_bReloadHudHintDisplayed = true; + m_flHudHintMinDisplayTime = gpGlobals->curtime + MIN_HUDHINT_DISPLAY_TIME; +#endif//CLIENT_DLL +} +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::RescindReloadHudHint() +{ +#if !defined( CLIENT_DLL ) + Assert(m_bReloadHudHintDisplayed); + + UTIL_HudHintText( GetOwner(), "" ); + --m_iReloadHudHintCount; + m_bReloadHudHintDisplayed = false; +#endif//CLIENT_DLL +} + + +void CBaseCombatWeapon::SetPickupTouch( void ) +{ +#if !defined( CLIENT_DLL ) + SetTouch(&CBaseCombatWeapon::DefaultTouch); + + if ( gpGlobals->maxClients > 1 ) + { + if ( GetSpawnFlags() & SF_NORESPAWN ) + { + SetThink( &CBaseEntity::SUB_Remove ); + SetNextThink( gpGlobals->curtime + 30.0f ); + } + } + +#endif +} + + +//----------------------------------------------------------------------------- +// Purpose: Become a child of the owner (MOVETYPE_FOLLOW) +// disables collisions, touch functions, thinking +// Input : *pOwner - new owner/operator +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::Equip( CBaseCombatCharacter *pOwner ) +{ + // Attach the weapon to an owner + SetAbsVelocity( vec3_origin ); + RemoveSolidFlags( FSOLID_TRIGGER ); + FollowEntity( pOwner ); + SetOwner( pOwner ); + SetOwnerEntity( pOwner ); + + // Break any constraint I might have to the world. + RemoveEffects( EF_ITEM_BLINK ); + +#if !defined( CLIENT_DLL ) + if ( m_pConstraint != NULL ) + { + RemoveSpawnFlags( SF_WEAPON_START_CONSTRAINED ); + physenv->DestroyConstraint( m_pConstraint ); + m_pConstraint = NULL; + } +#endif + + + m_flNextPrimaryAttack = gpGlobals->curtime; + m_flNextSecondaryAttack = gpGlobals->curtime; + SetTouch( NULL ); + SetThink( NULL ); +#if !defined( CLIENT_DLL ) + VPhysicsDestroyObject(); +#endif + + if ( pOwner->IsPlayer() ) + { + SetModel( GetViewModel() ); + } + else + { + // Make the weapon ready as soon as any NPC picks it up. + m_flNextPrimaryAttack = gpGlobals->curtime; + m_flNextSecondaryAttack = gpGlobals->curtime; + SetModel( GetWorldModel() ); + } +} + +void CBaseCombatWeapon::SetActivity( Activity act, float duration ) +{ + //Adrian: Oh man... +#if !defined( CLIENT_DLL ) && (defined( HL2MP ) || defined( PORTAL )) + SetModel( GetWorldModel() ); +#endif + + int sequence = SelectWeightedSequence( act ); + + // FORCE IDLE on sequences we don't have (which should be many) + if ( sequence == ACTIVITY_NOT_AVAILABLE ) + sequence = SelectWeightedSequence( ACT_VM_IDLE ); + + //Adrian: Oh man again... +#if !defined( CLIENT_DLL ) && (defined( HL2MP ) || defined( PORTAL )) + SetModel( GetViewModel() ); +#endif + + if ( sequence != ACTIVITY_NOT_AVAILABLE ) + { + SetSequence( sequence ); + SetActivity( act ); + SetCycle( 0 ); + ResetSequenceInfo( ); + + if ( duration > 0 ) + { + // FIXME: does this even make sense in non-shoot animations? + m_flPlaybackRate = SequenceDuration( sequence ) / duration; + m_flPlaybackRate = MIN( m_flPlaybackRate, 12.0); // FIXME; magic number!, network encoding range + } + else + { + m_flPlaybackRate = 1.0; + } + } +} + +//==================================================================================== +// WEAPON CLIENT HANDLING +//==================================================================================== +int CBaseCombatWeapon::UpdateClientData( CBasePlayer *pPlayer ) +{ + int iNewState = WEAPON_IS_CARRIED_BY_PLAYER; + + if ( pPlayer->GetActiveWeapon() == this ) + { + if ( pPlayer->m_fOnTarget ) + { + iNewState = WEAPON_IS_ONTARGET; + } + else + { + iNewState = WEAPON_IS_ACTIVE; + } + } + else + { + iNewState = WEAPON_IS_CARRIED_BY_PLAYER; + } + + if ( m_iState != iNewState ) + { + int iOldState = m_iState; + m_iState = iNewState; + OnActiveStateChanged( iOldState ); + } + return 1; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : index - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SetViewModelIndex( int index ) +{ + Assert( index >= 0 && index < MAX_VIEWMODELS ); + m_nViewModelIndex = index; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : iActivity - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SendViewModelAnim( int nSequence ) +{ +#if defined( CLIENT_DLL ) + if ( !IsPredicted() ) + return; +#endif + + if ( nSequence < 0 ) + return; + + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + + if ( pOwner == NULL ) + return; + + CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex, false ); + + if ( vm == NULL ) + return; + + SetViewModel(); + Assert( vm->ViewModelIndex() == m_nViewModelIndex ); + vm->SendViewModelMatchingSequence( nSequence ); +} + +float CBaseCombatWeapon::GetViewModelSequenceDuration() +{ + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner == NULL ) + { + Assert( false ); + return 0; + } + + CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex ); + if ( vm == NULL ) + { + Assert( false ); + return 0; + } + + SetViewModel(); + Assert( vm->ViewModelIndex() == m_nViewModelIndex ); + return vm->SequenceDuration(); +} + +bool CBaseCombatWeapon::IsViewModelSequenceFinished( void ) +{ + // These are not valid activities and always complete immediately + if ( GetActivity() == ACT_RESET || GetActivity() == ACT_INVALID ) + return true; + + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner == NULL ) + { + Assert( false ); + return false; + } + + CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex ); + if ( vm == NULL ) + { + Assert( false ); + return false; + } + + return vm->IsSequenceFinished(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SetViewModel() +{ + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner == NULL ) + return; + CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex, false ); + if ( vm == NULL ) + return; + Assert( vm->ViewModelIndex() == m_nViewModelIndex ); + vm->SetWeaponModel( GetViewModel( m_nViewModelIndex ), this ); +} + +//----------------------------------------------------------------------------- +// Purpose: Set the desired activity for the weapon and its viewmodel counterpart +// Input : iActivity - activity to play +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::SendWeaponAnim( int iActivity ) +{ +#ifdef USES_ECON_ITEMS + iActivity = TranslateViewmodelHandActivity( (Activity)iActivity ); +#endif + // NVNT notify the haptics system of this weapons new activity +#ifdef WIN32 +#ifdef CLIENT_DLL + if ( prediction->InPrediction() && prediction->IsFirstTimePredicted() ) +#endif +#ifndef _X360 + HapticSendWeaponAnim(this,iActivity); +#endif +#endif + //For now, just set the ideal activity and be done with it + return SetIdealActivity( (Activity) iActivity ); +} + +//==================================================================================== +// WEAPON SELECTION +//==================================================================================== + +//----------------------------------------------------------------------------- +// Purpose: Returns true if the weapon currently has ammo or doesn't need ammo +// Output : +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::HasAnyAmmo( void ) +{ + // If I don't use ammo of any kind, I can always fire + if ( !UsesPrimaryAmmo() && !UsesSecondaryAmmo() ) + return true; + + // Otherwise, I need ammo of either type + return ( HasPrimaryAmmo() || HasSecondaryAmmo() ); +} + +//----------------------------------------------------------------------------- +// Purpose: Returns true if the weapon currently has ammo or doesn't need ammo +// Output : +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::HasPrimaryAmmo( void ) +{ + // If I use a clip, and have some ammo in it, then I have ammo + if ( UsesClipsForAmmo1() ) + { + if ( m_iClip1 > 0 ) + return true; + } + + // Otherwise, I have ammo if I have some in my ammo counts + CBaseCombatCharacter *pOwner = GetOwner(); + if ( pOwner ) + { + if ( pOwner->GetAmmoCount( m_iPrimaryAmmoType ) > 0 ) + return true; + } + else + { + // No owner, so return how much primary ammo I have along with me. + if( GetPrimaryAmmoCount() > 0 ) + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns true if the weapon currently has ammo or doesn't need ammo +// Output : +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::HasSecondaryAmmo( void ) +{ + // If I use a clip, and have some ammo in it, then I have ammo + if ( UsesClipsForAmmo2() ) + { + if ( m_iClip2 > 0 ) + return true; + } + + // Otherwise, I have ammo if I have some in my ammo counts + CBaseCombatCharacter *pOwner = GetOwner(); + if ( pOwner ) + { + if ( pOwner->GetAmmoCount( m_iSecondaryAmmoType ) > 0 ) + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: returns true if the weapon actually uses primary ammo +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::UsesPrimaryAmmo( void ) +{ + if ( m_iPrimaryAmmoType < 0 ) + return false; + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: returns true if the weapon actually uses secondary ammo +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::UsesSecondaryAmmo( void ) +{ + if ( m_iSecondaryAmmoType < 0 ) + return false; + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Show/hide weapon and corresponding view model if any +// Input : visible - +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::SetWeaponVisible( bool visible ) +{ + CBaseViewModel *vm = NULL; + + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner ) + { + vm = pOwner->GetViewModel( m_nViewModelIndex ); + } + + if ( visible ) + { + RemoveEffects( EF_NODRAW ); + if ( vm ) + { + vm->RemoveEffects( EF_NODRAW ); + } + } + else + { + AddEffects( EF_NODRAW ); + if ( vm ) + { + vm->AddEffects( EF_NODRAW ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::IsWeaponVisible( void ) +{ + CBaseViewModel *vm = NULL; + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner ) + { + vm = pOwner->GetViewModel( m_nViewModelIndex ); + if ( vm ) + return ( !vm->IsEffectActive(EF_NODRAW) ); + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: If the current weapon has more ammo, reload it. Otherwise, switch +// to the next best weapon we've got. Returns true if it took any action. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::ReloadOrSwitchWeapons( void ) +{ + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + Assert( pOwner ); + + m_bFireOnEmpty = false; + + // If we don't have any ammo, switch to the next best weapon + if ( !HasAnyAmmo() && m_flNextPrimaryAttack < gpGlobals->curtime && m_flNextSecondaryAttack < gpGlobals->curtime ) + { + // weapon isn't useable, switch. + if ( ( (GetWeaponFlags() & ITEM_FLAG_NOAUTOSWITCHEMPTY) == false ) && ( g_pGameRules->SwitchToNextBestWeapon( pOwner, this ) ) ) + { + m_flNextPrimaryAttack = gpGlobals->curtime + 0.3; + return true; + } + } + else + { + // Weapon is useable. Reload if empty and weapon has waited as long as it has to after firing + if ( UsesClipsForAmmo1() && !AutoFiresFullClip() && + (m_iClip1 == 0) && + (GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) == false && + m_flNextPrimaryAttack < gpGlobals->curtime && + m_flNextSecondaryAttack < gpGlobals->curtime ) + { + // if we're successfully reloading, we're done + if ( Reload() ) + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *szViewModel - +// *szWeaponModel - +// iActivity - +// *szAnimExt - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt ) +{ + // Msg( "deploy %s at %f\n", GetClassname(), gpGlobals->curtime ); + + // Weapons that don't autoswitch away when they run out of ammo + // can still be deployed when they have no ammo. + if ( !HasAnyAmmo() && AllowsAutoSwitchFrom() ) + return false; + + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( pOwner ) + { + // Dead men deploy no weapons + if ( pOwner->IsAlive() == false ) + return false; + + pOwner->SetAnimationExtension( szAnimExt ); + + SetViewModel(); + SendWeaponAnim( iActivity ); + + pOwner->SetNextAttack( gpGlobals->curtime + SequenceDuration() ); + } + + // Can't shoot again until we've finished deploying + m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration(); + m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration(); + m_flHudHintMinDisplayTime = 0; + + m_bAltFireHudHintDisplayed = false; + m_bReloadHudHintDisplayed = false; + m_flHudHintPollTime = gpGlobals->curtime + 5.0f; + + WeaponSound( DEPLOY ); + + SetWeaponVisible( true ); + +/* + +This code is disabled for now, because moving through the weapons in the carousel +selects and deploys each weapon as you pass it. (sjb) + +*/ + + SetContextThink( NULL, 0, HIDEWEAPON_THINK_CONTEXT ); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::Deploy( ) +{ + MDLCACHE_CRITICAL_SECTION(); + return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), GetDrawActivity(), (char*)GetAnimPrefix() ); +} + +Activity CBaseCombatWeapon::GetDrawActivity( void ) +{ + return ACT_VM_DRAW; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::Holster( CBaseCombatWeapon *pSwitchingTo ) +{ + MDLCACHE_CRITICAL_SECTION(); + + // cancel any reload in progress. + m_bInReload = false; + m_bFiringWholeClip = false; + + // kill any think functions + SetThink(NULL); + + // Send holster animation + SendWeaponAnim( ACT_VM_HOLSTER ); + + // Some weapon's don't have holster anims yet, so detect that + float flSequenceDuration = 0; + if ( GetActivity() == ACT_VM_HOLSTER ) + { + flSequenceDuration = SequenceDuration(); + } + + CBaseCombatCharacter *pOwner = GetOwner(); + if (pOwner) + { + pOwner->SetNextAttack( gpGlobals->curtime + flSequenceDuration ); + } + + // If we don't have a holster anim, hide immediately to avoid timing issues + if ( !flSequenceDuration ) + { + SetWeaponVisible( false ); + } + else + { + // Hide the weapon when the holster animation's finished + SetContextThink( &CBaseCombatWeapon::HideThink, gpGlobals->curtime + flSequenceDuration, HIDEWEAPON_THINK_CONTEXT ); + } + + // if we were displaying a hud hint, squelch it. + if (m_flHudHintMinDisplayTime && gpGlobals->curtime < m_flHudHintMinDisplayTime) + { + if( m_bAltFireHudHintDisplayed ) + RescindAltFireHudHint(); + + if( m_bReloadHudHintDisplayed ) + RescindReloadHudHint(); + } + + return true; +} + +#ifdef CLIENT_DLL + + void CBaseCombatWeapon::BoneMergeFastCullBloat( Vector &localMins, Vector &localMaxs, const Vector &thisEntityMins, const Vector &thisEntityMaxs ) const + { + // The default behavior pushes it out by BONEMERGE_FASTCULL_BBOX_EXPAND in all directions, but we can do better + // since we know the weapon will never point behind him. + + localMaxs.x += 20; // Leaves some space in front for long weapons. + + localMins.y -= 20; // Fatten it to his left and right since he can rotate that way. + localMaxs.y += 20; + + localMaxs.z += 15; // Leave some space at the top. + } + +#else +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::InputHideWeapon( inputdata_t &inputdata ) +{ + // Only hide if we're still the active weapon. If we're not the active weapon + if ( GetOwner() && GetOwner()->GetActiveWeapon() == this ) + { + SetWeaponVisible( false ); + } +} +#endif + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::HideThink( void ) +{ + // Only hide if we're still the active weapon. If we're not the active weapon + if ( GetOwner() && GetOwner()->GetActiveWeapon() == this ) + { + SetWeaponVisible( false ); + } +} + +bool CBaseCombatWeapon::CanReload( void ) +{ + if ( AutoFiresFullClip() && m_bFiringWholeClip ) + { + return false; + } + + return true; +} + +#if defined ( TF_CLIENT_DLL ) || defined ( TF_DLL ) +//----------------------------------------------------------------------------- +// Purpose: Anti-hack +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::AddToCritBucket( float flAmount ) +{ + float flCap = tf_weapon_criticals_bucket_cap.GetFloat(); + + // Regulate crit frequency to reduce client-side seed hacking + if ( m_flCritTokenBucket < flCap ) + { + // Treat raw damage as the resource by which we add or subtract from the bucket + m_flCritTokenBucket += flAmount; + m_flCritTokenBucket = Min( m_flCritTokenBucket, flCap ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Anti-hack +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::IsAllowedToWithdrawFromCritBucket( float flDamage ) +{ + // Note: If we're in this block of code, the assumption is that the + // seed said we should grant a random crit. If allowed, the cost + // will be deducted here. + + // Track each seed request - in cases where a player is hacking, we'll + // see a silly ratio. + m_nCritSeedRequests++; + + // Adjust token cost based on the ratio of requests vs granted, except + // melee, which crits much more than ranged (as high as 60% chance) + float flMult = ( IsMeleeWeapon() ) ? 0.5f : RemapValClamped( ( (float)m_nCritSeedRequests / (float)m_nCritChecks ), 0.1f, 1.f, 1.f, 3.f ); + + // Would this take us below our limit? + float flCost = ( flDamage * TF_DAMAGE_CRIT_MULTIPLIER ) * flMult; + if ( flCost > m_flCritTokenBucket ) + return false; + + // Withdraw + RemoveFromCritBucket( flCost ); + + float flBottom = tf_weapon_criticals_bucket_bottom.GetFloat(); + if ( m_flCritTokenBucket < flBottom ) + m_flCritTokenBucket = flBottom; + + return true; +} +#endif // TF_DLL + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::ItemPreFrame( void ) +{ + MaintainIdealActivity(); + +#ifndef CLIENT_DLL +#ifndef HL2_EPISODIC + if ( IsX360() ) +#endif + { + // If we haven't displayed the hint enough times yet, it's time to try to + // display the hint, and the player is not standing still, try to show a hud hint. + // If the player IS standing still, assume they could change away from this weapon at + // any second. + if( (!m_bAltFireHudHintDisplayed || !m_bReloadHudHintDisplayed) && gpGlobals->curtime > m_flHudHintMinDisplayTime && gpGlobals->curtime > m_flHudHintPollTime && GetOwner() && GetOwner()->IsPlayer() ) + { + CBasePlayer *pPlayer = (CBasePlayer*)(GetOwner()); + + if( pPlayer && pPlayer->GetStickDist() > 0.0f ) + { + // If the player is moving, they're unlikely to switch away from the current weapon + // the moment this weapon displays its HUD hint. + if( ShouldDisplayReloadHUDHint() ) + { + DisplayReloadHudHint(); + } + else if( ShouldDisplayAltFireHUDHint() ) + { + DisplayAltFireHudHint(); + } + } + else + { + m_flHudHintPollTime = gpGlobals->curtime + 2.0f; + } + } + } +#endif +} + +//==================================================================================== +// WEAPON BEHAVIOUR +//==================================================================================== +void CBaseCombatWeapon::ItemPostFrame( void ) +{ + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if (!pOwner) + return; + + UpdateAutoFire(); + + //Track the duration of the fire + //FIXME: Check for IN_ATTACK2 as well? + //FIXME: What if we're calling ItemBusyFrame? + m_fFireDuration = ( pOwner->m_nButtons & IN_ATTACK ) ? ( m_fFireDuration + gpGlobals->frametime ) : 0.0f; + + if ( UsesClipsForAmmo1() ) + { + CheckReload(); + } + + bool bFired = false; + + // Secondary attack has priority + if ((pOwner->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime)) + { + if (UsesSecondaryAmmo() && pOwner->GetAmmoCount(m_iSecondaryAmmoType)<=0 ) + { + if (m_flNextEmptySoundTime < gpGlobals->curtime) + { + WeaponSound(EMPTY); + m_flNextSecondaryAttack = m_flNextEmptySoundTime = gpGlobals->curtime + 0.5; + } + } + else if (pOwner->GetWaterLevel() == 3 && m_bAltFiresUnderwater == false) + { + // This weapon doesn't fire underwater + WeaponSound(EMPTY); + m_flNextPrimaryAttack = gpGlobals->curtime + 0.2; + return; + } + else + { + // FIXME: This isn't necessarily true if the weapon doesn't have a secondary fire! + // For instance, the crossbow doesn't have a 'real' secondary fire, but it still + // stops the crossbow from firing on the 360 if the player chooses to hold down their + // zoom button. (sjb) Orange Box 7/25/2007 +#if !defined(CLIENT_DLL) + if( !IsX360() || !ClassMatches("weapon_crossbow") ) +#endif + { + bFired = ShouldBlockPrimaryFire(); + } + + SecondaryAttack(); + + // Secondary ammo doesn't have a reload animation + if ( UsesClipsForAmmo2() ) + { + // reload clip2 if empty + if (m_iClip2 < 1) + { + pOwner->RemoveAmmo( 1, m_iSecondaryAmmoType ); + m_iClip2 = m_iClip2 + 1; + } + } + } + } + + if ( !bFired && (pOwner->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime)) + { + // Clip empty? Or out of ammo on a no-clip weapon? + if ( !IsMeleeWeapon() && + (( UsesClipsForAmmo1() && m_iClip1 <= 0) || ( !UsesClipsForAmmo1() && pOwner->GetAmmoCount(m_iPrimaryAmmoType)<=0 )) ) + { + HandleFireOnEmpty(); + } + else if (pOwner->GetWaterLevel() == 3 && m_bFiresUnderwater == false) + { + // This weapon doesn't fire underwater + WeaponSound(EMPTY); + m_flNextPrimaryAttack = gpGlobals->curtime + 0.2; + return; + } + else + { + //NOTENOTE: There is a bug with this code with regards to the way machine guns catch the leading edge trigger + // on the player hitting the attack key. It relies on the gun catching that case in the same frame. + // However, because the player can also be doing a secondary attack, the edge trigger may be missed. + // We really need to hold onto the edge trigger and only clear the condition when the gun has fired its + // first shot. Right now that's too much of an architecture change -- jdw + + // If the firing button was just pressed, or the alt-fire just released, reset the firing time + if ( ( pOwner->m_afButtonPressed & IN_ATTACK ) || ( pOwner->m_afButtonReleased & IN_ATTACK2 ) ) + { + m_flNextPrimaryAttack = gpGlobals->curtime; + } + + PrimaryAttack(); + + if ( AutoFiresFullClip() ) + { + m_bFiringWholeClip = true; + } + +#ifdef CLIENT_DLL + pOwner->SetFiredWeapon( true ); +#endif + } + } + + // ----------------------- + // Reload pressed / Clip Empty + // ----------------------- + if ( ( pOwner->m_nButtons & IN_RELOAD ) && UsesClipsForAmmo1() && !m_bInReload ) + { + // reload when reload is pressed, or if no buttons are down and weapon is empty. + Reload(); + m_fFireDuration = 0.0f; + } + + // ----------------------- + // No buttons down + // ----------------------- + if (!((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (CanReload() && pOwner->m_nButtons & IN_RELOAD))) + { + // no fire buttons down or reloading + if ( !ReloadOrSwitchWeapons() && ( m_bInReload == false ) ) + { + WeaponIdle(); + } + } +} + +void CBaseCombatWeapon::HandleFireOnEmpty() +{ + // If we're already firing on empty, reload if we can + if ( m_bFireOnEmpty ) + { + ReloadOrSwitchWeapons(); + m_fFireDuration = 0.0f; + } + else + { + if (m_flNextEmptySoundTime < gpGlobals->curtime) + { + WeaponSound(EMPTY); + m_flNextEmptySoundTime = gpGlobals->curtime + 0.5; + } + m_bFireOnEmpty = true; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Called each frame by the player PostThink, if the player's not ready to attack yet +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::ItemBusyFrame( void ) +{ + UpdateAutoFire(); +} + +//----------------------------------------------------------------------------- +// Purpose: Base class default for getting bullet type +// Input : +// Output : +//----------------------------------------------------------------------------- +int CBaseCombatWeapon::GetBulletType( void ) +{ + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: Base class default for getting spread +// Input : +// Output : +//----------------------------------------------------------------------------- +const Vector& CBaseCombatWeapon::GetBulletSpread( void ) +{ + static Vector cone = VECTOR_CONE_15DEGREES; + return cone; +} + +//----------------------------------------------------------------------------- +const WeaponProficiencyInfo_t *CBaseCombatWeapon::GetProficiencyValues() +{ + static WeaponProficiencyInfo_t defaultWeaponProficiencyTable[] = + { + { 1.0, 1.0 }, + { 1.0, 1.0 }, + { 1.0, 1.0 }, + { 1.0, 1.0 }, + { 1.0, 1.0 }, + }; + + COMPILE_TIME_ASSERT( ARRAYSIZE(defaultWeaponProficiencyTable) == WEAPON_PROFICIENCY_PERFECT + 1); + return defaultWeaponProficiencyTable; +} + +//----------------------------------------------------------------------------- +// Purpose: Base class default for getting firerate +// Input : +// Output : +//----------------------------------------------------------------------------- +float CBaseCombatWeapon::GetFireRate( void ) +{ + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: Base class default for playing shoot sound +// Input : +// Output : +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::WeaponSound( WeaponSound_t sound_type, float soundtime /* = 0.0f */ ) +{ + // If we have some sounds from the weapon classname.txt file, play a random one of them + const char *shootsound = GetShootSound( sound_type ); + if ( !shootsound || !shootsound[0] ) + return; + + CSoundParameters params; + + if ( !GetParametersForSound( shootsound, params, NULL ) ) + return; + + if ( params.play_to_owner_only ) + { + // Am I only to play to my owner? + if ( GetOwner() && GetOwner()->IsPlayer() ) + { + CSingleUserRecipientFilter filter( ToBasePlayer( GetOwner() ) ); + if ( IsPredicted() && CBaseEntity::GetPredictionPlayer() ) + { + filter.UsePredictionRules(); + } + EmitSound( filter, GetOwner()->entindex(), shootsound, NULL, soundtime ); + } + } + else + { + // Play weapon sound from the owner + if ( GetOwner() ) + { + CPASAttenuationFilter filter( GetOwner(), params.soundlevel ); + if ( IsPredicted() && CBaseEntity::GetPredictionPlayer() ) + { + filter.UsePredictionRules(); + } + EmitSound( filter, GetOwner()->entindex(), shootsound, NULL, soundtime ); + +#if !defined( CLIENT_DLL ) + if( sound_type == EMPTY ) + { + CSoundEnt::InsertSound( SOUND_COMBAT, GetOwner()->GetAbsOrigin(), SOUNDENT_VOLUME_EMPTY, 0.2, GetOwner() ); + } +#endif + } + // If no owner play from the weapon (this is used for thrown items) + else + { + CPASAttenuationFilter filter( this, params.soundlevel ); + if ( IsPredicted() && CBaseEntity::GetPredictionPlayer() ) + { + filter.UsePredictionRules(); + } + EmitSound( filter, entindex(), shootsound, NULL, soundtime ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Stop a sound played by this weapon. +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::StopWeaponSound( WeaponSound_t sound_type ) +{ + //if ( IsPredicted() ) + // return; + + // If we have some sounds from the weapon classname.txt file, play a random one of them + const char *shootsound = GetShootSound( sound_type ); + if ( !shootsound || !shootsound[0] ) + return; + + CSoundParameters params; + if ( !GetParametersForSound( shootsound, params, NULL ) ) + return; + + // Am I only to play to my owner? + if ( params.play_to_owner_only ) + { + if ( GetOwner() ) + { + StopSound( GetOwner()->entindex(), shootsound ); + } + } + else + { + // Play weapon sound from the owner + if ( GetOwner() ) + { + StopSound( GetOwner()->entindex(), shootsound ); + } + // If no owner play from the weapon (this is used for thrown items) + else + { + StopSound( entindex(), shootsound ); + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::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; + +#ifdef CLIENT_DLL + // Play reload + WeaponSound( RELOAD ); +#endif + SendWeaponAnim( iActivity ); + + // Play the player's reload animation + if ( pOwner->IsPlayer() ) + { + ( ( CBasePlayer * )pOwner)->SetAnimation( PLAYER_RELOAD ); + } + + MDLCACHE_CRITICAL_SECTION(); + float flSequenceEndTime = gpGlobals->curtime + SequenceDuration(); + pOwner->SetNextAttack( flSequenceEndTime ); + m_flNextPrimaryAttack = m_flNextSecondaryAttack = flSequenceEndTime; + + m_bInReload = true; + + return true; +} + +bool CBaseCombatWeapon::ReloadsSingly( void ) const +{ +#if defined ( TF_DLL ) || defined ( TF_CLIENT_DLL ) + float fHasReload = 1.0f; + CALL_ATTRIB_HOOK_FLOAT( fHasReload, mod_no_reload_display_only ); + if ( fHasReload != 1.0f ) + { + return false; + } + + int iWeaponMod = 0; + CALL_ATTRIB_HOOK_INT( iWeaponMod, set_scattergun_no_reload_single ); + if ( iWeaponMod == 1 ) + { + return false; + } +#endif // TF_DLL || TF_CLIENT_DLL + + return m_bReloadsSingly; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::Reload( void ) +{ + return DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD ); +} + +//========================================================= +void CBaseCombatWeapon::WeaponIdle( void ) +{ + //Idle again if we've finished + if ( HasWeaponIdleTimeElapsed() ) + { + SendWeaponAnim( ACT_VM_IDLE ); + } +} + + +//========================================================= +Activity CBaseCombatWeapon::GetPrimaryAttackActivity( void ) +{ + return ACT_VM_PRIMARYATTACK; +} + +//========================================================= +Activity CBaseCombatWeapon::GetSecondaryAttackActivity( void ) +{ + return ACT_VM_SECONDARYATTACK; +} + +//----------------------------------------------------------------------------- +// Purpose: Adds in view kick and weapon accuracy degradation effect +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::AddViewKick( void ) +{ + //NOTENOTE: By default, weapon will not kick up (defined per weapon) +} + +//----------------------------------------------------------------------------- +// Purpose: Get the string to print death notices with +//----------------------------------------------------------------------------- +char *CBaseCombatWeapon::GetDeathNoticeName( void ) +{ +#if !defined( CLIENT_DLL ) + return (char*)STRING( m_iszName ); +#else + return "GetDeathNoticeName not implemented on client yet"; +#endif +} + +//==================================================================================== +// WEAPON RELOAD TYPES +//==================================================================================== +void CBaseCombatWeapon::CheckReload( void ) +{ + if ( m_bReloadsSingly ) + { + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( !pOwner ) + return; + + if ((m_bInReload) && (m_flNextPrimaryAttack <= gpGlobals->curtime)) + { + if ( pOwner->m_nButtons & (IN_ATTACK | IN_ATTACK2) && m_iClip1 > 0 ) + { + m_bInReload = false; + return; + } + + // If out of ammo end reload + if (pOwner->GetAmmoCount(m_iPrimaryAmmoType) <=0) + { + FinishReload(); + return; + } + // If clip not full reload again + else if (m_iClip1 < GetMaxClip1()) + { + // Add them to the clip + m_iClip1 += 1; + pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType ); + + Reload(); + return; + } + // Clip full, stop reloading + else + { + FinishReload(); + m_flNextPrimaryAttack = gpGlobals->curtime; + m_flNextSecondaryAttack = gpGlobals->curtime; + return; + } + } + } + else + { + if ( (m_bInReload) && (m_flNextPrimaryAttack <= gpGlobals->curtime)) + { + FinishReload(); + m_flNextPrimaryAttack = gpGlobals->curtime; + m_flNextSecondaryAttack = gpGlobals->curtime; + m_bInReload = false; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Reload has finished. +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::FinishReload( void ) +{ + CBaseCombatCharacter *pOwner = GetOwner(); + + if (pOwner) + { + // If I use primary clips, reload primary + if ( UsesClipsForAmmo1() ) + { + int primary = MIN( GetMaxClip1() - m_iClip1, pOwner->GetAmmoCount(m_iPrimaryAmmoType)); + m_iClip1 += primary; + pOwner->RemoveAmmo( primary, m_iPrimaryAmmoType); + } + + // If I use secondary clips, reload secondary + if ( UsesClipsForAmmo2() ) + { + int secondary = MIN( GetMaxClip2() - m_iClip2, pOwner->GetAmmoCount(m_iSecondaryAmmoType)); + m_iClip2 += secondary; + pOwner->RemoveAmmo( secondary, m_iSecondaryAmmoType ); + } + + if ( m_bReloadsSingly ) + { + m_bInReload = false; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: Abort any reload we have in progress +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::AbortReload( void ) +{ +#ifdef CLIENT_DLL + StopWeaponSound( RELOAD ); +#endif + m_bInReload = false; +} + +void CBaseCombatWeapon::UpdateAutoFire( void ) +{ + if ( !AutoFiresFullClip() ) + return; + + CBasePlayer *pOwner = ToBasePlayer( GetOwner() ); + if ( !pOwner ) + return; + + if ( m_iClip1 == 0 ) + { + // Ready to reload again + m_bFiringWholeClip = false; + } + + if ( m_bFiringWholeClip ) + { + // If it's firing the clip don't let them repress attack to reload + pOwner->m_nButtons &= ~IN_ATTACK; + } + + // Don't use the regular reload key + if ( pOwner->m_nButtons & IN_RELOAD ) + { + pOwner->m_nButtons &= ~IN_RELOAD; + } + + // Try to fire if there's ammo in the clip and we're not holding the button + bool bReleaseClip = m_iClip1 > 0 && !( pOwner->m_nButtons & IN_ATTACK ); + + if ( !bReleaseClip ) + { + if ( CanReload() && ( pOwner->m_nButtons & IN_ATTACK ) ) + { + // Convert the attack key into the reload key + pOwner->m_nButtons |= IN_RELOAD; + } + + // Don't allow attack button if we're not attacking + pOwner->m_nButtons &= ~IN_ATTACK; + } + else + { + // Fake the attack key + pOwner->m_nButtons |= IN_ATTACK; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Primary fire button attack +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::PrimaryAttack( void ) +{ + // If my clip is empty (and I use clips) start reload + if ( UsesClipsForAmmo1() && !m_iClip1 ) + { + Reload(); + return; + } + + // Only the player fires this way so we can cast + CBasePlayer *pPlayer = ToBasePlayer( GetOwner() ); + + if (!pPlayer) + { + return; + } + + pPlayer->DoMuzzleFlash(); + + SendWeaponAnim( GetPrimaryAttackActivity() ); + + // player "shoot" animation + pPlayer->SetAnimation( PLAYER_ATTACK1 ); + + FireBulletsInfo_t info; + info.m_vecSrc = pPlayer->Weapon_ShootPosition( ); + + info.m_vecDirShooting = pPlayer->GetAutoaimVector( AUTOAIM_SCALE_DEFAULT ); + + // To make the firing framerate independent, we may have to fire more than one bullet here on low-framerate systems, + // especially if the weapon we're firing has a really fast rate of fire. + info.m_iShots = 0; + float fireRate = GetFireRate(); + + while ( m_flNextPrimaryAttack <= gpGlobals->curtime ) + { + // MUST call sound before removing a round from the clip of a CMachineGun + WeaponSound(SINGLE, m_flNextPrimaryAttack); + m_flNextPrimaryAttack = m_flNextPrimaryAttack + fireRate; + info.m_iShots++; + if ( !fireRate ) + break; + } + + // Make sure we don't fire more than the amount in the clip + if ( UsesClipsForAmmo1() ) + { + info.m_iShots = MIN( info.m_iShots, m_iClip1 ); + m_iClip1 -= info.m_iShots; + } + else + { + info.m_iShots = MIN( info.m_iShots, pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) ); + pPlayer->RemoveAmmo( info.m_iShots, m_iPrimaryAmmoType ); + } + + info.m_flDistance = MAX_TRACE_LENGTH; + info.m_iAmmoType = m_iPrimaryAmmoType; + info.m_iTracerFreq = 2; + +#if !defined( CLIENT_DLL ) + // Fire the bullets + info.m_vecSpread = pPlayer->GetAttackSpread( this ); +#else + //!!!HACKHACK - what does the client want this function for? + info.m_vecSpread = GetActiveWeapon()->GetBulletSpread(); +#endif // CLIENT_DLL + + pPlayer->FireBullets( info ); + + if (!m_iClip1 && pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0) + { + // HEV suit - indicate out of ammo condition + pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0); + } + + //Add our view kick in + AddViewKick(); +} + +//----------------------------------------------------------------------------- +// Purpose: Called every frame to check if the weapon is going through transition animations +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::MaintainIdealActivity( void ) +{ + // Must be transitioning + if ( GetActivity() != ACT_TRANSITION ) + return; + + // Must not be at our ideal already + if ( ( GetActivity() == m_IdealActivity ) && ( GetSequence() == m_nIdealSequence ) ) + return; + + // Must be finished with the current animation + if ( IsViewModelSequenceFinished() == false ) + return; + + // Move to the next animation towards our ideal + SendWeaponAnim( m_IdealActivity ); +} + +//----------------------------------------------------------------------------- +// Purpose: Sets the ideal activity for the weapon to be in, allowing for transitional animations inbetween +// Input : ideal - activity to end up at, ideally +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::SetIdealActivity( Activity ideal ) +{ + MDLCACHE_CRITICAL_SECTION(); + int idealSequence = SelectWeightedSequence( ideal ); + + if ( idealSequence == -1 ) + return false; + + //Take the new activity + m_IdealActivity = ideal; + m_nIdealSequence = idealSequence; + + //Find the next sequence in the potential chain of sequences leading to our ideal one + int nextSequence = FindTransitionSequence( GetSequence(), m_nIdealSequence, NULL ); + + // Don't use transitions when we're deploying + if ( ideal != ACT_VM_DRAW && IsWeaponVisible() && nextSequence != m_nIdealSequence ) + { + //Set our activity to the next transitional animation + SetActivity( ACT_TRANSITION ); + SetSequence( nextSequence ); + SendViewModelAnim( nextSequence ); + } + else + { + //Set our activity to the ideal + SetActivity( m_IdealActivity ); + SetSequence( m_nIdealSequence ); + SendViewModelAnim( m_nIdealSequence ); + } + + //Set the next time the weapon will idle + SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() ); + return true; +} + +//----------------------------------------------------------------------------- +// Returns information about the various control panels +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName ) +{ + pPanelName = NULL; +} + +//----------------------------------------------------------------------------- +// Returns information about the various control panels +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::GetControlPanelClassName( int nPanelIndex, const char *&pPanelName ) +{ + pPanelName = "vgui_screen"; +} + + +//----------------------------------------------------------------------------- +// Locking a weapon is an exclusive action. If you lock a weapon, that means +// you are preventing others from doing so for themselves. +//----------------------------------------------------------------------------- +void CBaseCombatWeapon::Lock( float lockTime, CBaseEntity *pLocker ) +{ + m_flUnlockTime = gpGlobals->curtime + lockTime; + m_hLocker.Set( pLocker ); +} + +//----------------------------------------------------------------------------- +// If I'm still locked for a period of time, tell everyone except the person +// that locked me that I'm not available. +//----------------------------------------------------------------------------- +bool CBaseCombatWeapon::IsLocked( CBaseEntity *pAsker ) +{ + return ( m_flUnlockTime > gpGlobals->curtime && m_hLocker != pAsker ); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : +// Output : +//----------------------------------------------------------------------------- +Activity CBaseCombatWeapon::ActivityOverride( Activity baseAct, bool *pRequired ) +{ + acttable_t *pTable = ActivityList(); + int actCount = ActivityListCount(); + + for ( int i = 0; i < actCount; i++, pTable++ ) + { + if ( baseAct == pTable->baseAct ) + { + if (pRequired) + { + *pRequired = pTable->required; + } + return (Activity)pTable->weaponAct; + } + } + return baseAct; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CDmgAccumulator::CDmgAccumulator( void ) +{ +#ifdef GAME_DLL + SetDefLessFunc( m_TargetsDmgInfo ); +#endif // GAME_DLL + + m_bActive = false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CDmgAccumulator::~CDmgAccumulator() +{ + // Did a weapon get deleted while aggregating CTakeDamageInfo events? + Assert( !m_bActive ); +} + +#ifdef GAME_DLL +//----------------------------------------------------------------------------- +// Collect trace attacks for weapons that fire multiple bullets per attack that also penetrate +//----------------------------------------------------------------------------- +void CDmgAccumulator::AccumulateMultiDamage( const CTakeDamageInfo &info, CBaseEntity *pEntity ) +{ + if ( !pEntity ) + return; + + Assert( m_bActive ); + +#if defined( GAME_DLL ) + int iIndex = m_TargetsDmgInfo.Find( pEntity->entindex() ); + if ( iIndex == m_TargetsDmgInfo.InvalidIndex() ) + { + m_TargetsDmgInfo.Insert( pEntity->entindex(), info ); + } + else + { + CTakeDamageInfo *pInfo = &m_TargetsDmgInfo[iIndex]; + if ( pInfo ) + { + // Update + m_TargetsDmgInfo[iIndex].AddDamageType( info.GetDamageType() ); + m_TargetsDmgInfo[iIndex].SetDamage( pInfo->GetDamage() + info.GetDamage() ); + m_TargetsDmgInfo[iIndex].SetDamageForce( pInfo->GetDamageForce() + info.GetDamageForce() ); + m_TargetsDmgInfo[iIndex].SetDamagePosition( info.GetDamagePosition() ); + m_TargetsDmgInfo[iIndex].SetReportedPosition( info.GetReportedPosition() ); + m_TargetsDmgInfo[iIndex].SetMaxDamage( MAX( pInfo->GetMaxDamage(), info.GetDamage() ) ); + m_TargetsDmgInfo[iIndex].SetAmmoType( info.GetAmmoType() ); + } + + } +#endif // GAME_DLL +} + +//----------------------------------------------------------------------------- +// Purpose: Send aggregate info +//----------------------------------------------------------------------------- +void CDmgAccumulator::Process( void ) +{ + FOR_EACH_MAP( m_TargetsDmgInfo, i ) + { + CBaseEntity *pEntity = UTIL_EntityByIndex( m_TargetsDmgInfo.Key( i ) ); + if ( pEntity ) + { + AddMultiDamage( m_TargetsDmgInfo[i], pEntity ); + } + } + + m_bActive = false; + m_TargetsDmgInfo.Purge(); +} +#endif // GAME_DLL + +#if defined( CLIENT_DLL ) + +BEGIN_PREDICTION_DATA( CBaseCombatWeapon ) + + DEFINE_PRED_FIELD( m_nNextThinkTick, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + // Networked + DEFINE_PRED_FIELD( m_hOwner, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ), + // DEFINE_FIELD( m_hWeaponFileInfo, FIELD_SHORT ), + DEFINE_PRED_FIELD( m_iState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iViewModelIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE | FTYPEDESC_MODELINDEX ), + DEFINE_PRED_FIELD( m_iWorldModelIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE | FTYPEDESC_MODELINDEX ), + DEFINE_PRED_FIELD_TOL( m_flNextPrimaryAttack, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ), + DEFINE_PRED_FIELD_TOL( m_flNextSecondaryAttack, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ), + DEFINE_PRED_FIELD_TOL( m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ), + + DEFINE_PRED_FIELD( m_iPrimaryAmmoType, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iSecondaryAmmoType, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iClip1, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + DEFINE_PRED_FIELD( m_iClip2, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + + DEFINE_PRED_FIELD( m_nViewModelIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ), + + // Not networked + + DEFINE_PRED_FIELD( m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ), + DEFINE_FIELD( m_bInReload, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bFireOnEmpty, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bFiringWholeClip, FIELD_BOOLEAN ), + DEFINE_FIELD( m_flNextEmptySoundTime, FIELD_FLOAT ), + DEFINE_FIELD( m_Activity, FIELD_INTEGER ), + DEFINE_FIELD( m_fFireDuration, FIELD_FLOAT ), + DEFINE_FIELD( m_iszName, FIELD_INTEGER ), + DEFINE_FIELD( m_bFiresUnderwater, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bAltFiresUnderwater, FIELD_BOOLEAN ), + DEFINE_FIELD( m_fMinRange1, FIELD_FLOAT ), + DEFINE_FIELD( m_fMinRange2, FIELD_FLOAT ), + DEFINE_FIELD( m_fMaxRange1, FIELD_FLOAT ), + DEFINE_FIELD( m_fMaxRange2, FIELD_FLOAT ), + DEFINE_FIELD( m_bReloadsSingly, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bRemoveable, FIELD_BOOLEAN ), + DEFINE_FIELD( m_iPrimaryAmmoCount, FIELD_INTEGER ), + DEFINE_FIELD( m_iSecondaryAmmoCount, FIELD_INTEGER ), + + //DEFINE_PHYSPTR( m_pConstraint ), + + // DEFINE_FIELD( m_iOldState, FIELD_INTEGER ), + // DEFINE_FIELD( m_bJustRestored, FIELD_BOOLEAN ), + + // DEFINE_FIELD( m_OnPlayerPickup, COutputEvent ), + // DEFINE_FIELD( m_pConstraint, FIELD_INTEGER ), + +END_PREDICTION_DATA() + +#endif // ! CLIENT_DLL + +// Special hack since we're aliasing the name C_BaseCombatWeapon with a macro on the client +IMPLEMENT_NETWORKCLASS_ALIASED( BaseCombatWeapon, DT_BaseCombatWeapon ) + +#if !defined( CLIENT_DLL ) +//----------------------------------------------------------------------------- +// Purpose: Save Data for Base Weapon object +//-----------------------------------------------------------------------------// +BEGIN_DATADESC( CBaseCombatWeapon ) + + DEFINE_FIELD( m_flNextPrimaryAttack, FIELD_TIME ), + DEFINE_FIELD( m_flNextSecondaryAttack, FIELD_TIME ), + DEFINE_FIELD( m_flTimeWeaponIdle, FIELD_TIME ), + + DEFINE_FIELD( m_bInReload, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bFireOnEmpty, FIELD_BOOLEAN ), + DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ), + + DEFINE_FIELD( m_iState, FIELD_INTEGER ), + DEFINE_FIELD( m_iszName, FIELD_STRING ), + DEFINE_FIELD( m_iPrimaryAmmoType, FIELD_INTEGER ), + DEFINE_FIELD( m_iSecondaryAmmoType, FIELD_INTEGER ), + DEFINE_FIELD( m_iClip1, FIELD_INTEGER ), + DEFINE_FIELD( m_iClip2, FIELD_INTEGER ), + DEFINE_FIELD( m_bFiresUnderwater, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bAltFiresUnderwater, FIELD_BOOLEAN ), + DEFINE_FIELD( m_fMinRange1, FIELD_FLOAT ), + DEFINE_FIELD( m_fMinRange2, FIELD_FLOAT ), + DEFINE_FIELD( m_fMaxRange1, FIELD_FLOAT ), + DEFINE_FIELD( m_fMaxRange2, FIELD_FLOAT ), + + DEFINE_FIELD( m_iPrimaryAmmoCount, FIELD_INTEGER ), + DEFINE_FIELD( m_iSecondaryAmmoCount, FIELD_INTEGER ), + + DEFINE_FIELD( m_nViewModelIndex, FIELD_INTEGER ), + +// don't save these, init to 0 and regenerate +// DEFINE_FIELD( m_flNextEmptySoundTime, FIELD_TIME ), +// DEFINE_FIELD( m_Activity, FIELD_INTEGER ), + DEFINE_FIELD( m_nIdealSequence, FIELD_INTEGER ), + DEFINE_FIELD( m_IdealActivity, FIELD_INTEGER ), + + DEFINE_FIELD( m_fFireDuration, FIELD_FLOAT ), + + DEFINE_FIELD( m_bReloadsSingly, FIELD_BOOLEAN ), + DEFINE_FIELD( m_iSubType, FIELD_INTEGER ), + DEFINE_FIELD( m_bRemoveable, FIELD_BOOLEAN ), + + DEFINE_FIELD( m_flUnlockTime, FIELD_TIME ), + DEFINE_FIELD( m_hLocker, FIELD_EHANDLE ), + + // DEFINE_FIELD( m_iViewModelIndex, FIELD_INTEGER ), + // DEFINE_FIELD( m_iWorldModelIndex, FIELD_INTEGER ), + // DEFINE_FIELD( m_hWeaponFileInfo, ???? ), + + DEFINE_PHYSPTR( m_pConstraint ), + + DEFINE_FIELD( m_iReloadHudHintCount, FIELD_INTEGER ), + DEFINE_FIELD( m_iAltFireHudHintCount, FIELD_INTEGER ), + DEFINE_FIELD( m_bReloadHudHintDisplayed, FIELD_BOOLEAN ), + DEFINE_FIELD( m_bAltFireHudHintDisplayed, FIELD_BOOLEAN ), + DEFINE_FIELD( m_flHudHintPollTime, FIELD_TIME ), + DEFINE_FIELD( m_flHudHintMinDisplayTime, FIELD_TIME ), + + // Just to quiet classcheck.. this field exists only on the client +// DEFINE_FIELD( m_iOldState, FIELD_INTEGER ), +// DEFINE_FIELD( m_bJustRestored, FIELD_BOOLEAN ), + + // Function pointers + DEFINE_ENTITYFUNC( DefaultTouch ), + DEFINE_THINKFUNC( FallThink ), + DEFINE_THINKFUNC( Materialize ), + DEFINE_THINKFUNC( AttemptToMaterialize ), + DEFINE_THINKFUNC( DestroyItem ), + DEFINE_THINKFUNC( SetPickupTouch ), + + DEFINE_THINKFUNC( HideThink ), + DEFINE_INPUTFUNC( FIELD_VOID, "HideWeapon", InputHideWeapon ), + + // Outputs + DEFINE_OUTPUT( m_OnPlayerUse, "OnPlayerUse"), + DEFINE_OUTPUT( m_OnPlayerPickup, "OnPlayerPickup"), + DEFINE_OUTPUT( m_OnNPCPickup, "OnNPCPickup"), + DEFINE_OUTPUT( m_OnCacheInteraction, "OnCacheInteraction" ), + +END_DATADESC() + +//----------------------------------------------------------------------------- +// Purpose: Only send to local player if this weapon is the active weapon +// Input : *pStruct - +// *pVarData - +// *pRecipients - +// objectID - +// Output : void* +//----------------------------------------------------------------------------- +void* SendProxy_SendActiveLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) +{ + // Get the weapon entity + CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData; + if ( pWeapon ) + { + // Only send this chunk of data to the player carrying this weapon + CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() ); + if ( pPlayer /*&& pPlayer->GetActiveWeapon() == pWeapon*/ ) + { + pRecipients->SetOnly( pPlayer->GetClientIndex() ); + return (void*)pVarData; + } + } + + return NULL; +} +REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendActiveLocalWeaponDataTable ); + +//----------------------------------------------------------------------------- +// Purpose: Only send the LocalWeaponData to the player carrying the weapon +//----------------------------------------------------------------------------- +void* SendProxy_SendLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) +{ + // Get the weapon entity + CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData; + if ( pWeapon ) + { + // Only send this chunk of data to the player carrying this weapon + CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() ); + if ( pPlayer ) + { + pRecipients->SetOnly( pPlayer->GetClientIndex() ); + return (void*)pVarData; + } + } + + return NULL; +} +REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendLocalWeaponDataTable ); + +//----------------------------------------------------------------------------- +// Purpose: Only send to non-local players +//----------------------------------------------------------------------------- +void* SendProxy_SendNonLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ) +{ + pRecipients->SetAllRecipients(); + + CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData; + if ( pWeapon ) + { + CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() ); + if ( pPlayer ) + { + pRecipients->ClearRecipient( pPlayer->GetClientIndex() ); + return ( void * )pVarData; + } + } + + return NULL; +} +REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendNonLocalWeaponDataTable ); + +#endif + +#if PREDICTION_ERROR_CHECK_LEVEL > 1 +#define SendPropTime SendPropFloat +#define RecvPropTime RecvPropFloat +#endif + +//----------------------------------------------------------------------------- +// Purpose: Propagation data for weapons. Only sent when a player's holding it. +//----------------------------------------------------------------------------- +BEGIN_NETWORK_TABLE_NOBASE( CBaseCombatWeapon, DT_LocalActiveWeaponData ) +#if !defined( CLIENT_DLL ) + SendPropTime( SENDINFO( m_flNextPrimaryAttack ) ), + SendPropTime( SENDINFO( m_flNextSecondaryAttack ) ), + SendPropInt( SENDINFO( m_nNextThinkTick ) ), + SendPropTime( SENDINFO( m_flTimeWeaponIdle ) ), + +#if defined( TF_DLL ) + SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ), +#endif + +#else + RecvPropTime( RECVINFO( m_flNextPrimaryAttack ) ), + RecvPropTime( RECVINFO( m_flNextSecondaryAttack ) ), + RecvPropInt( RECVINFO( m_nNextThinkTick ) ), + RecvPropTime( RECVINFO( m_flTimeWeaponIdle ) ), +#endif +END_NETWORK_TABLE() + +//----------------------------------------------------------------------------- +// Purpose: Propagation data for weapons. Only sent when a player's holding it. +//----------------------------------------------------------------------------- +BEGIN_NETWORK_TABLE_NOBASE( CBaseCombatWeapon, DT_LocalWeaponData ) +#if !defined( CLIENT_DLL ) + SendPropIntWithMinusOneFlag( SENDINFO(m_iClip1 ), 8 ), + SendPropIntWithMinusOneFlag( SENDINFO(m_iClip2 ), 8 ), + SendPropInt( SENDINFO(m_iPrimaryAmmoType ), 8 ), + SendPropInt( SENDINFO(m_iSecondaryAmmoType ), 8 ), + + SendPropInt( SENDINFO( m_nViewModelIndex ), VIEWMODEL_INDEX_BITS, SPROP_UNSIGNED ), + + SendPropInt( SENDINFO( m_bFlipViewModel ) ), + +#if defined( TF_DLL ) + SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ), +#endif + +#else + RecvPropIntWithMinusOneFlag( RECVINFO(m_iClip1 )), + RecvPropIntWithMinusOneFlag( RECVINFO(m_iClip2 )), + RecvPropInt( RECVINFO(m_iPrimaryAmmoType )), + RecvPropInt( RECVINFO(m_iSecondaryAmmoType )), + + RecvPropInt( RECVINFO( m_nViewModelIndex ) ), + + RecvPropBool( RECVINFO( m_bFlipViewModel ) ), + +#endif +END_NETWORK_TABLE() + +BEGIN_NETWORK_TABLE(CBaseCombatWeapon, DT_BaseCombatWeapon) +#if !defined( CLIENT_DLL ) + SendPropDataTable("LocalWeaponData", 0, &REFERENCE_SEND_TABLE(DT_LocalWeaponData), SendProxy_SendLocalWeaponDataTable ), + SendPropDataTable("LocalActiveWeaponData", 0, &REFERENCE_SEND_TABLE(DT_LocalActiveWeaponData), SendProxy_SendActiveLocalWeaponDataTable ), + SendPropModelIndex( SENDINFO(m_iViewModelIndex) ), + SendPropModelIndex( SENDINFO(m_iWorldModelIndex) ), + SendPropInt( SENDINFO(m_iState ), 8, SPROP_UNSIGNED ), + SendPropEHandle( SENDINFO(m_hOwner) ), +#else + RecvPropDataTable("LocalWeaponData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalWeaponData)), + RecvPropDataTable("LocalActiveWeaponData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalActiveWeaponData)), + RecvPropInt( RECVINFO(m_iViewModelIndex)), + RecvPropInt( RECVINFO(m_iWorldModelIndex)), + RecvPropInt( RECVINFO(m_iState )), + RecvPropEHandle( RECVINFO(m_hOwner ) ), +#endif +END_NETWORK_TABLE() -- cgit v1.2.3