tf2/tf2_src/game/shared/tf/tf_weaponbase.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//	Weapons.
//
//	CTFWeaponBase
//	|
//	|--> CTFWeaponBaseMelee
//	|		|
//	|		|--> CTFWeaponCrowbar
//	|		|--> CTFWeaponKnife
//	|		|--> CTFWeaponMedikit
//	|		|--> CTFWeaponWrench
//	|
//	|--> CTFWeaponBaseGrenade
//	|		|
//	|		|--> CTFWeapon
//	|		|--> CTFWeapon
//	|
//	|--> CTFWeaponBaseGun
//
//=============================================================================
#ifndef TF_WEAPONBASE_H
#define TF_WEAPONBASE_H
#ifdef _WIN32
#pragma once
#endif

#include "tf_playeranimstate.h"
#include "tf_weapon_parse.h"
#include "npcevent.h"
#include "ihasowner.h"
#include "tf_item_wearable.h"

// Client specific.
#if defined( CLIENT_DLL )
#define CTFWeaponBase C_TFWeaponBase
#define CTFWeaponAttachmentModel C_TFWeaponAttachmentModel
#define CTFWeaponBaseGrenadeProj C_TFWeaponBaseGrenadeProj
#include "tf_fx_muzzleflash.h"
#include "GameEventListener.h"
#endif

#define MAX_TRACER_NAME		128

class CTFPlayer;
class CBaseObject;
class CTFWeaponBaseGrenadeProj;
class CTFWeaponAttachmentModel;

// Given an ammo type (like from a weapon's GetPrimaryAmmoType()), this compares it
// against the ammo name you specify.
// TFTODO: this should use indexing instead of searching and strcmp()'ing all the time.
bool IsAmmoType( int iAmmoType, const char *pAmmoName );
void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity );

// Reloading singly.
enum
{
	TF_RELOAD_START = 0,
	TF_RELOADING,
	TF_RELOADING_CONTINUE,
	TF_RELOAD_FINISH
};

// structure to encapsulate state of head bob
struct BobState_t
{
	BobState_t() 
	{ 
		m_flBobTime = 0; 
		m_flLastBobTime = 0;
		m_flLastSpeed = 0;
		m_flVerticalBob = 0;
		m_flLateralBob = 0;
	}

	float m_flBobTime;
	float m_flLastBobTime;
	float m_flLastSpeed;
	float m_flVerticalBob;
	float m_flLateralBob;
};

enum EWeaponStrangeType_t
{
	STRANGE_UNKNOWN = -1,
	STRANGE_NOT_STRANGE = 0,
	STRANGE_IS_STRANGE = 1,
};

enum EWeaponStatTrakModuleType_t
{
	MODULE_UNKNOWN = -1,
	MODULE_NONE = 0,
	MODULE_FOUND = 1,
};

#ifdef CLIENT_DLL
float CalcViewModelBobHelper( CBasePlayer *player, BobState_t *pBobState );
void AddViewModelBobHelper( Vector &origin, QAngle &angles, BobState_t *pBobState );
#endif

// Interface for weapons that have a charge time
class ITFChargeUpWeapon 
{
public:
	virtual bool CanCharge( void ) = 0;

	virtual float GetChargeBeginTime( void ) = 0;

	virtual float GetChargeMaxTime( void ) = 0;

	virtual float GetCurrentCharge( void )
	{ 
		return ( gpGlobals->curtime - GetChargeBeginTime() ) / GetChargeMaxTime();
	}
};

class CTraceFilterIgnoreTeammates : public CTraceFilterSimple
{
public:
	// It does have a base, but we'll never network anything below here..
	DECLARE_CLASS( CTraceFilterIgnoreTeammates, CTraceFilterSimple );

	CTraceFilterIgnoreTeammates( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam )
		: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam )
	{
	}

	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
	{
		CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );

		if ( ( pEntity->IsPlayer() || pEntity->IsCombatItem() ) && ( pEntity->GetTeamNumber() == m_iIgnoreTeam || m_iIgnoreTeam == TEAM_ANY ) )
		{
			return false;
		}

		return BaseClass::ShouldHitEntity( pServerEntity, contentsMask );
	}

	int m_iIgnoreTeam;
};

class CTraceFilterIgnorePlayers : public CTraceFilterSimple
{
public:
	// It does have a base, but we'll never network anything below here..
	DECLARE_CLASS( CTraceFilterIgnorePlayers, CTraceFilterSimple );

	CTraceFilterIgnorePlayers( const IHandleEntity *passentity, int collisionGroup )
		: CTraceFilterSimple( passentity, collisionGroup )
	{
	}

	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
	{
		CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );
		if ( pEntity && pEntity->IsPlayer() )
			return false;

		return BaseClass::ShouldHitEntity( pServerEntity, contentsMask );
	}
};

class CTraceFilterIgnoreFriendlyCombatItems : public CTraceFilterSimple
{
public:
	DECLARE_CLASS( CTraceFilterIgnoreFriendlyCombatItems, CTraceFilterSimple );

	CTraceFilterIgnoreFriendlyCombatItems( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam, bool bIsProjectile = false )
		: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam )
	{
		m_bCallerIsProjectile = bIsProjectile;
	}

	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
	{
		CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );

// 		if ( ( pEntity->MyCombatCharacterPointer() || pEntity->MyCombatWeaponPointer() ) && pEntity->GetTeamNumber() == m_iIgnoreTeam )
// 			return false;
// 
// 		if ( pEntity->IsPlayer() && pEntity->GetTeamNumber() == m_iIgnoreTeam )
// 			return false;

		if ( pEntity->IsCombatItem() )
		{
			if ( pEntity->GetTeamNumber() == m_iIgnoreTeam )
				return false;

			// If source is a enemy projectile, be explicit, otherwise we fail a "IsTransparent" test downstream
			if ( m_bCallerIsProjectile )
				return true;
		}

		return BaseClass::ShouldHitEntity( pServerEntity, contentsMask );
	}

	int m_iIgnoreTeam;
	bool m_bCallerIsProjectile;
};

#define ENERGY_WEAPON_MAX_CHARGE		20

#define TF_PARTICLE_WEAPON_BLUE_1	Vector( 0.345, 0.52, 0.635 )
#define TF_PARTICLE_WEAPON_BLUE_2	Vector( 0.145, 0.427, 0.55 )
#define TF_PARTICLE_WEAPON_RED_1	Vector( 0.72, 0.22, 0.23 )
#define TF_PARTICLE_WEAPON_RED_2	Vector( 0.5, 0.18, 0.125 )

//=============================================================================
//
// Base TF Weapon Class
//
#if defined( CLIENT_DLL )
class CTFWeaponBase : public CBaseCombatWeapon, public IHasOwner, public CGameEventListener
#else
class CTFWeaponBase : public CBaseCombatWeapon, public IHasOwner
#endif
{
	DECLARE_CLASS( CTFWeaponBase, CBaseCombatWeapon );
	DECLARE_NETWORKCLASS(); 
	DECLARE_PREDICTABLE();
#if !defined ( CLIENT_DLL )
	DECLARE_DATADESC();
#endif

	// Setup.
	CTFWeaponBase();
	~CTFWeaponBase();

	virtual void Spawn();
	virtual void Activate( void );
	virtual void Precache();
	virtual bool IsPredicted() const			{ return true; }
	virtual void FallInit( void );

	// Weapon Data.
	CTFWeaponInfo const	&GetTFWpnData() const;
	virtual int GetWeaponID( void ) const;
	bool IsWeapon( int iWeapon ) const;
	virtual int	GetDamageType() const { return g_aWeaponDamageTypes[ GetWeaponID() ]; }
	virtual int GetCustomDamageType() const { return TF_DMG_CUSTOM_NONE; }
	virtual int	GetMaxClip1( void ) const;
	virtual int GetDefaultClip1( void ) const;
	virtual bool UsesPrimaryAmmo();
	virtual float UberChargeAmmoPerShot( void ) { float fAmmo = 0; CALL_ATTRIB_HOOK_FLOAT( fAmmo, ubercharge_ammo ); return fAmmo * 0.01f; }

	virtual int	Clip1() { return IsEnergyWeapon() ? Energy_GetEnergy() : m_iClip1; }
	virtual int	Clip2() { return m_iClip2; }

	virtual bool HasAmmo( void );

	// View model.
	virtual const char *GetViewModel( int iViewModel = 0 ) const;
	virtual const char *GetWorldModel( void ) const;

	virtual bool SendWeaponAnim( int iActivity ) OVERRIDE;

	virtual CBaseEntity	*GetOwnerViaInterface( void ) { return GetOwner(); }

	virtual void Equip( CBaseCombatCharacter *pOwner );
	virtual void Drop( const Vector &vecVelocity );
	virtual void UpdateOnRemove( void );
	virtual bool CanHolster( void ) const;
	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
	virtual bool Deploy( void );
	virtual bool ForceWeaponSwitch() const OVERRIDE;
	virtual void Detach( void );
	virtual void OnActiveStateChanged( int iOldState );
	virtual bool OwnerCanJump( void ) { return true; }
	virtual bool VisibleInWeaponSelection( void );
	virtual void UpdateHands( void );

	virtual bool OwnerCanTaunt( void ) { return true; }
	virtual bool CanBeCritBoosted( void );
	bool CanHaveRevengeCrits( void );

	// Extra wearables.
#ifdef GAME_DLL
	virtual void ChangeTeam( int iTeamNum ) OVERRIDE;	
	virtual void UpdateExtraWearables();
	virtual void ExtraWearableEquipped( CTFWearable *pExtraWearableItem );
	virtual void ExtraWearableViewModelEquipped( CTFWearable *pExtraWearableItem );
	virtual bool HideAttachmentsAndShowBodygroupsWhenPerformingWeaponIndependentTaunt() const { return true; }
#endif // GAME_DLL
	virtual void RemoveExtraWearables( void );

	// Attacks.
	virtual void Misfire( void );
	virtual void FireFullClipAtOnce( void );
	virtual void PrimaryAttack();
	virtual void SecondaryAttack();
	void CalcIsAttackCritical( void );
	virtual bool CalcIsAttackCriticalHelper();
	virtual bool CalcIsAttackCriticalHelperNoCrits();
	bool IsCurrentAttackACrit() const { return m_bCurrentAttackIsCrit; }
	bool IsCurrentAttackARandomCrit() const { return m_bCurrentAttackIsCrit && m_bCurrentCritIsRandom; }
	bool IsCurrentAttackDuringDemoCharge() const { return m_bCurrentAttackIsDuringDemoCharge; }
	virtual ETFDmgCustom GetPenetrateType() const;
	virtual void GetProjectileFireSetup( CTFPlayer *pPlayer, Vector vecOffset, Vector *vecSrc, QAngle *angForward, bool bHitTeammates = true, float flEndDist = 2000.f );
	virtual QAngle GetSpreadAngles( void );
	float GetLastPrimaryAttackTime( void ) const { return m_flLastPrimaryAttackTime; }
	virtual bool CanPerformSecondaryAttack() const OVERRIDE;
	virtual bool IsFiring( void ) const { return false; }
	virtual bool AreRandomCritsEnabled( void );

	// Reloads.
	virtual bool Reload( void );
	virtual void AbortReload( void );
	virtual bool DefaultReload( int iClipSize1, int iClipSize2, int iActivity );
	void SendReloadEvents();
	virtual bool IsReloading() const;			// is the weapon reloading right now?

	virtual bool AutoFiresFullClip( void ) const OVERRIDE;
	bool AutoFiresFullClipAllAtOnce( void ) const;
	bool CanOverload( void ) const;
	virtual bool CheckReloadMisfire( void ) { return false; }

	virtual bool CanDrop( void ) { return false; }
	virtual bool AllowTaunts( void ) { return true; }

	// Fire Rate
	float ApplyFireDelay( float flDelay ) const;

	// Sound.
	bool PlayEmptySound();
	bool IsSilentKiller();

	// Activities.
	virtual void ItemBusyFrame( void );
	virtual void ItemPostFrame( void );
	virtual void ItemHolsterFrame( void );

	virtual void SetWeaponVisible( bool visible );

	virtual int GetActivityWeaponRole() const;
	virtual acttable_t *ActivityList( int &iActivityCount ) OVERRIDE;

	virtual Activity	TranslateViewmodelHandActivityInternal( Activity actBase );
	virtual int			GetViewModelWeaponRole() { return GetTFWpnData().m_iWeaponType; }

#ifdef GAME_DLL
	virtual void	AddAssociatedObject( CBaseObject *pObject ) { }
	virtual void	RemoveAssociatedObject( CBaseObject *pObject ) { }

	virtual void	ApplyOnHitAttributes( CBaseEntity *pVictimBaseEntity, CTFPlayer *pAttacker, const CTakeDamageInfo &info );
	virtual void	ApplyPostHitEffects( const CTakeDamageInfo &inputInfo, CTFPlayer *pPlayer );
	virtual void	ApplyOnInjuredAttributes( CTFPlayer *pVictim, CTFPlayer *pAttacker, const CTakeDamageInfo &info );		// when owner of this weapon is hit

	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );

	virtual bool	DeflectProjectiles();
	virtual bool	DeflectPlayer( CTFPlayer *pTarget, CTFPlayer *pOwner, Vector &vecForward, Vector &vecCenter, Vector &vecSize );
	virtual bool	DeflectEntity( CBaseEntity *pTarget, CTFPlayer *pOwner, Vector &vecForward, Vector &vecCenter, Vector &vecSize );
	static void		SendObjectDeflectedEvent( CTFPlayer *pNewOwner, CTFPlayer *pPrevOwner, int iWeaponID, CBaseAnimating *pObject );
	static float	DeflectionForce( const Vector &size, float damage, float scale );
	virtual void	PlayDeflectionSound( bool bPlayer ) {}
	virtual Vector	GetDeflectionSize() { return Vector( 128, 128, 64 ); }

	virtual float	GetJarateTime() { return 0.f; }

	void			ApplyItemRegen( void );

	kill_eater_event_t GetKillEaterKillEventType() const;
#endif

	// Utility.
	CBasePlayer *GetPlayerOwner() const;
	CTFPlayer *GetTFPlayerOwner() const;

#ifdef CLIENT_DLL
	virtual bool	ShouldPlayClientReloadSound() { return false; }

	C_BaseEntity *GetWeaponForEffect();

	virtual const char* ModifyEventParticles( const char* token ) { return token; }

	// Shadows
	virtual ShadowType_t ShadowCastType( void ) OVERRIDE;
#endif

	virtual bool	CanAttack();
	virtual int		GetCanAttackFlags() const { return TF_CAN_ATTACK_FLAG_NONE; }

	// Raising & Lowering for grenade throws
	bool			WeaponShouldBeLowered( void );
	virtual bool	Ready( void );
	virtual bool	Lower( void );

	virtual void	WeaponIdle( void );

	virtual void	WeaponReset( void );
	virtual void	WeaponRegenerate( void );

	// Muzzleflashes
	virtual const char *GetMuzzleFlashEffectName_3rd( void ) { return NULL; }
	virtual const char *GetMuzzleFlashEffectName_1st( void ) { return NULL; }
	virtual const char *GetMuzzleFlashModel( void );
	virtual float	GetMuzzleFlashModelLifetime( void );
	virtual const char *GetMuzzleFlashParticleEffect( void );

	virtual const char	*GetTracerType( void );

	virtual void Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator );

	// CEconEntity
	virtual const char *GetInventoryModel( void );
	virtual void		ReapplyProvision( void );
	virtual float		GetSpeedMod( void ) { return 1.f; };

	virtual bool		CanFireCriticalShot( bool bIsHeadshot = false );
	virtual bool		CanFireRandomCriticalShot( float flCritChance );

	virtual char const	*GetShootSound( int iIndex ) const;
	void			UpdateHiddenParentBodygroup( bool bHide );

	virtual void		OnControlStunned( void );

	virtual bool		HideWhileStunned( void ) { return true; }

	virtual bool IsViewModelFlipped( void );

	virtual int			GetMaxHealthMod() { return 0; }

	virtual float		GetLastDeployTime( void ) { return m_flLastDeployTime; }

	// Energy Weapons
	virtual bool		IsEnergyWeapon( void ) const { return false; }
	virtual bool		IsBlastImpactWeapon( void ) const { return false; }
	float				Energy_GetMaxEnergy( void ) const;
	float				Energy_GetEnergy( void ) const { return m_flEnergy; }
	void				Energy_SetEnergy( float flEnergy ) { m_flEnergy = flEnergy; }
	bool				Energy_FullyCharged( void ) const;
	bool				Energy_HasEnergy( void );
	void				Energy_DrainEnergy( void );
	void				Energy_DrainEnergy( float flDrain );
	bool				Energy_Recharge( void );
	virtual float		Energy_GetShotCost( void ) const { return 4.f; }
	virtual float		Energy_GetRechargeCost( void ) const { return 4.f; }

	virtual Vector		GetParticleColor( int iColor );

	virtual void		CheckReload( void );
	virtual void		FinishReload( void );

	virtual bool		HasLastShotCritical( void ) { return false; }

	virtual bool		UseServerRandomSeed( void ) const { return true; }

// Server specific.
#if !defined( CLIENT_DLL )

	// Spawning.
	virtual void CheckRespawn();
	virtual CBaseEntity* Respawn();
	void Materialize();
	void AttemptToMaterialize();

	// Death.
	void Die( void );
	void SetDieThink( bool bDie );

	// Disguise weapon.
	void DisguiseWeaponThink( void );

	// Ammo.
	virtual const Vector& GetBulletSpread();

	// Hit tracking for achievements
	// Track the number of kills we've had since we missed. Only works for bullet firing weapons right now.
	virtual void	OnBulletFire( int iEnemyPlayersHit );
	virtual void	OnPlayerKill( CTFPlayer *pVictim, const CTakeDamageInfo &info );
	virtual float	GetLastHitTime( void ) { return m_flLastHitTime; }

	virtual int		GetDropSkinOverride( void ) { return -1; }

	int				GetKillStreak () const { return m_iKillStreak; }
	void			SetKillStreak ( int value ) { m_iKillStreak = value; };

	float			GetClipScale () const { return m_flClipScale; }
	void			SetClipScale ( float flScale ) { m_flClipScale = flScale; }
// Client specific.
#else

	bool			IsFirstPersonView();
	bool			UsingViewModel();
	C_BaseAnimating *GetAppropriateWorldOrViewModel();

	virtual bool	ShouldDraw( void ) OVERRIDE;
	virtual void	UpdateVisibility( void ) OVERRIDE;

	virtual void	ProcessMuzzleFlashEvent( void );
	virtual void	DispatchMuzzleFlash( const char* effectName, C_BaseEntity* pAttachEnt );
	virtual int		InternalDrawModel( int flags );

	virtual bool	ShouldPredict();
	virtual void	PostDataUpdate( DataUpdateType_t updateType );
	virtual void	OnDataChanged( DataUpdateType_t type );
	virtual void	OnPreDataChanged( DataUpdateType_t updateType );
	virtual int		GetWorldModelIndex( void );
	virtual bool	ShouldDrawCrosshair( void );
	virtual void	Redraw( void );
	virtual void	FireGameEvent( IGameEvent *event );

	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
	virtual	float	CalcViewmodelBob( void );
	BobState_t		*GetBobState();
	virtual bool	AttachmentModelsShouldBeVisible( void ) OVERRIDE { return (m_iState == WEAPON_IS_ACTIVE) && !IsBeingRepurposedForTaunt(); }

	virtual bool ShouldEjectBrass() { return true; }

	bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );

	// ItemEffect Hud defaults
	virtual const char * GetEffectLabelText()	{ return ""; }
	virtual float GetProgress()					{ return 0; }

	// Model muzzleflashes
	CHandle<C_MuzzleFlashModel>		m_hMuzzleFlashModel[2];

	bool			IsUsingOverrideModel() const { return m_iWorldModelIndex != m_iCachedModelIndex; }

#endif

	virtual int		GetSkin();

	static void UpdateWeaponBodyGroups( CTFPlayer* pPlayer, bool bHandleDeployedBodygroups );
	void SetIsBeingRepurposedForTaunt( bool bCanOverride )	{ m_bBeingRepurposedForTaunt = bCanOverride; }
	bool IsBeingRepurposedForTaunt() const { return m_bBeingRepurposedForTaunt; }

	int GetKillComboClass( void ) const { return m_nKillComboClass; }
	int GetKillComboCount( void ) const { return m_nKillComboCount; }
	void ClearKillComboCount( void ) { m_nKillComboCount = 0; }
	void AddKillCombo( int nClassKilled )
	{
		if ( m_nKillComboClass != nClassKilled )
		{
			m_nKillComboClass = nClassKilled;
			ClearKillComboCount();
		}

		m_nKillComboCount = Min( 3, m_nKillComboCount + 1 );
	}

	// Effect / Regeneration bar handling
	virtual float	GetEffectBarProgress( void );			// Get the current bar state (will return a value from 0.0 to 1.0)
	bool			HasEffectBarRegeneration( void ) { return InternalGetEffectBarRechargeTime() > 0; }	// Check the base, not modified by attribute, because attrib may have reduced it to 0.
	float			GetEffectBarRechargeTime( void ) { float flTime = InternalGetEffectBarRechargeTime(); CALL_ATTRIB_HOOK_FLOAT( flTime, effectbar_recharge_rate ); return flTime; }
	void			DecrementBarRegenTime( float flTime ) { m_flEffectBarRegenTime -= flTime; }

	bool			IsHonorBound( void ) const;

	virtual bool	CanPickupOtherWeapon() const { return true; }

	EWeaponStrangeType_t	GetStrangeType();
	bool					BHasStatTrakModule();
#ifdef CLIENT_DLL
	// StatTrak View Model Test
	void					UpdateAllViewmodelAddons( void );

	void					AddStatTrakModel( CEconItemView *pItem, int nStatTrakType, AccountID_t holderAcctId );
	void					RemoveViewmodelStatTrak( void );
	void					RemoveWorldmodelStatTrak( void );

	CHandle< CTFWeaponAttachmentModel > m_viewmodelStatTrakAddon;
	CHandle< CTFWeaponAttachmentModel > m_worldmodelStatTrakAddon;

	virtual const Vector&	GetViewmodelOffset() OVERRIDE;
#endif

	virtual bool ShouldRemoveInvisibilityOnPrimaryAttack() const { return true; }

protected:
	virtual int		GetEffectBarAmmo( void ) { return m_iPrimaryAmmoType; }
	virtual float	InternalGetEffectBarRechargeTime( void ) { return 0; }	// Time it takes for this regeneration bar to fully recharge from 0 to full.

	void			StartEffectBarRegen( void );						// Call this when you want your bar to start recharging (usually when you've deployed your action)
	void			EffectBarRegenFinished( void );
	void			CheckEffectBarRegen( void );

private:
	CNetworkVar(	float, m_flEffectBarRegenTime );	// The time Regen is scheduled to complete

protected:
#ifdef CLIENT_DLL
	virtual void CreateMuzzleFlashEffects( C_BaseEntity *pAttachEnt, int nIndex );

	virtual void UpdateExtraWearablesVisibility();
#endif // CLIENT_DLL

	// Reloads.
	void UpdateReloadTimers( bool bStart );
	void SetReloadTimer( float flReloadTime );
	bool ReloadSingly( void );
	void ReloadSinglyPostFrame( void );
	void IncrementAmmo( void );

	bool NeedsReloadForAmmo1( int iClipSize1 ) const;
	bool NeedsReloadForAmmo2( int iClipSize2 ) const;

protected:

	void			PlayUpgradedShootSound( const char *pszSound );

	int				m_iWeaponMode;
	CNetworkVar(	int,	m_iReloadMode );
	CNetworkVar( float, m_flReloadPriorNextFire );
	CTFWeaponInfo	*m_pWeaponInfo;
	bool			m_bInAttack;
	bool			m_bInAttack2;
	bool			m_bCurrentAttackIsCrit;
	bool			m_bCurrentCritIsRandom;
	bool			m_bCurrentAttackIsDuringDemoCharge;

	EWeaponStrangeType_t			m_eStrangeType;
	EWeaponStatTrakModuleType_t		m_eStatTrakModuleType;

	CNetworkVar(	bool,	m_bLowered );

	int				m_iAltFireHint;

	int				m_iReloadStartClipAmount;

	float			m_flCritTime;
	CNetworkVar( float, m_flLastCritCheckTime );	// Deprecated
	int				m_iLastCritCheckFrame;
	int				m_iCurrentSeed;
	float			m_flLastRapidFireCritCheckTime;

	float			m_flLastDeployTime;

	char			m_szTracerName[MAX_TRACER_NAME];

	CNetworkVar(	bool, m_bResetParity );

	int				m_iAmmoToAdd;
	float			m_flLastPrimaryAttackTime;

#ifdef GAME_DLL
	// Stores the number of kills we've made since we last shot & didn't hit a player.
	// Only hooked up to bullet firing right now, so you'll need to do plumbing if you want it for other weaponry.
	int				m_iConsecutiveKills;

	// Accuracy tracking
	float			m_flLastHitTime;
	int				m_iHitsInTime;
	int				m_iFiredInTime;

	// Used to generate active-weapon-only regen
	float			m_flRegenTime;

	// for penetrating weapons with drain - only drain each victim once
	CHandle< CTFPlayer > m_hLastDrainVictim;
	CountdownTimer m_lastDrainVictimTimer;

	int				m_iKillStreak;
	float			m_flClipScale;
#endif

#ifdef CLIENT_DLL
	bool m_bOldResetParity;
	int m_iCachedModelIndex;
	int m_iEjectBrassAttachpoint;

#endif

	CNetworkVar(	bool,	m_bReloadedThroughAnimEvent );

	CNetworkVar( float, m_flEnergy );

public:
	CNetworkVar(	bool, m_bDisguiseWeapon );

	CNetworkVar(	float, m_flLastFireTime );

	CNetworkHandle( CTFWearable, m_hExtraWearable );
	CNetworkHandle( CTFWearable, m_hExtraWearableViewModel );

	CNetworkVar( float, m_flObservedCritChance );

	virtual bool CanInspect() const;
	void HandleInspect();

	enum TFWeaponInspectStage
	{
		INSPECT_INVALID = -1,
		INSPECT_START,
		INSPECT_IDLE,
		INSPECT_END,

		INSPECT_STAGE_COUNT
	};
	TFWeaponInspectStage GetInspectStage() const { return (TFWeaponInspectStage)m_nInspectStage.Get(); }
	float GetInspectAnimTime() const { return m_flInspectAnimTime; }

private:
	CTFWeaponBase( const CTFWeaponBase & );

	CNetworkVar( bool, m_bBeingRepurposedForTaunt );

	CNetworkVar( int,	m_nKillComboClass );
	CNetworkVar( int,	m_nKillComboCount );
	
	int GetInspectActivity( TFWeaponInspectStage inspectStage );
	bool IsInspectActivity( int iActivity );
	CNetworkVar( float, m_flInspectAnimTime );
	CNetworkVar( int, m_nInspectStage );
	bool m_bInspecting;

	friend class CTFDroppedWeapon;

#ifdef CLIENT_DLL
	bool m_bInitViewmodelOffset;
	Vector m_vecViewmodelOffset;
#endif // CLIENT_DLL
};

bool WeaponID_IsSniperRifle( int iWeaponID );
bool WeaponID_IsSniperRifleOrBow( int iWeaponID );

#define WEAPON_RANDOM_RANGE 10000

#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// CTFWeaponAttachmentModel 
//-----------------------------------------------------------------------------
class CTFWeaponAttachmentModel : public CBaseAnimating, public IHasOwner
{
	DECLARE_CLASS( CTFWeaponAttachmentModel, CBaseAnimating );
public:
	CTFWeaponAttachmentModel() { m_bIsViewModelAttachment = false; m_hWeaponAssociatedWith = NULL; }

	virtual bool ShouldDraw( void );
	
	void				Init( CBaseEntity *pParent, CTFWeaponBase *pAssociatedWeapon, bool bIsViewModel );
	void				SetWeaponAssociatedWith( CTFWeaponBase *pWeapon ) { m_hWeaponAssociatedWith = pWeapon; }
	CBaseEntity*		GetWeaponAssociatedWith( void ) const { return m_hWeaponAssociatedWith.Get(); }

	bool BIsViewModelAttachment() { return m_bIsViewModelAttachment; }
	
	virtual CBaseEntity	*GetOwnerViaInterface( void ) OVERRIDE { return m_hWeaponAssociatedWith.Get() ? m_hWeaponAssociatedWith.Get()->GetOwner() : NULL; }
private:

	bool m_bIsViewModelAttachment;
	CHandle< CTFWeaponBase > m_hWeaponAssociatedWith;
};
#endif // CLIENT_DLL

#endif // TF_WEAPONBASE_H