//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // //===========================================================================// #ifndef COMBATWEAPON_SHARED_H #define COMBATWEAPON_SHARED_H #ifdef _WIN32 #pragma once #endif #include "sharedInterface.h" #include "vphysics_interface.h" #include "predictable_entity.h" #include "soundflags.h" #include "weapon_parse.h" #include "baseviewmodel_shared.h" #include "weapon_proficiency.h" #include "utlmap.h" #if defined( CLIENT_DLL ) #define CBaseCombatWeapon C_BaseCombatWeapon #endif // Hacky #if defined ( TF_CLIENT_DLL ) || defined ( TF_DLL ) #include "econ_entity.h" #endif // TF_CLIENT_DLL || TF_DLL #if !defined( CLIENT_DLL ) extern void OnBaseCombatWeaponCreated( CBaseCombatWeapon * ); extern void OnBaseCombatWeaponDestroyed( CBaseCombatWeapon * ); void *SendProxy_SendLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID ); #endif class CBasePlayer; class CBaseCombatCharacter; class IPhysicsConstraint; class CUserCmd; // How many times to display altfire hud hints (per weapon) #define WEAPON_ALTFIRE_HUD_HINT_COUNT 1 #define WEAPON_RELOAD_HUD_HINT_COUNT 1 //Start with a constraint in place (don't drop to floor) #define SF_WEAPON_START_CONSTRAINED (1<<0) #define SF_WEAPON_NO_PLAYER_PICKUP (1<<1) #define SF_WEAPON_NO_PHYSCANNON_PUNT (1<<2) //Percent #define CLIP_PERC_THRESHOLD 0.75f // Put this in your derived class definition to declare it's activity table // UNDONE: Cascade these? #define DECLARE_ACTTABLE() static acttable_t m_acttable[];\ virtual acttable_t *ActivityList( int &iActivityCount ) OVERRIDE; // You also need to include the activity table itself in your class' implementation: // e.g. // acttable_t CWeaponStunstick::m_acttable[] = // { // { ACT_MELEE_ATTACK1, ACT_MELEE_ATTACK_SWING, TRUE }, // }; // // The stunstick overrides the ACT_MELEE_ATTACK1 activity, replacing it with ACT_MELEE_ATTACK_SWING. // This animation is required for this weapon's operation. // // Put this after your derived class' definition to implement the accessors for the // activity table. // UNDONE: Cascade these? #define IMPLEMENT_ACTTABLE(className) \ acttable_t *className::ActivityList( int &iActivityCount ) { iActivityCount = ARRAYSIZE(m_acttable); return m_acttable; } typedef struct { int baseAct; int weaponAct; bool required; } acttable_t; struct poseparamtable_t { const char *pszName; float flValue; }; // Put this in your derived class definition to declare it's poseparam table #define DECLARE_POSEPARAMTABLE() static poseparamtable_t m_poseparamtable[];\ virtual poseparamtable_t* PoseParamList( int &iPoseParamCount ) { return NULL; } // You also need to include the activity table itself in your class' implementation: // e.g. // acttable_t CTFGrapplingHook::m_poseparamtable[] = // { // { "r_arm", 2 }, // }; // // The grapplinghook overrides the r_arm pose param, value to 2. #define IMPLEMENT_POSEPARAMTABLE(className)\ poseparamtable_t* className::PoseParamList( int &iPoseParamCount ) { iPoseParamCount = ARRAYSIZE(m_poseparamtable); return m_poseparamtable; } class CHudTexture; class Color; namespace vgui2 { typedef unsigned long HFont; } // ----------------------------------------- // Vector cones // ----------------------------------------- // VECTOR_CONE_PRECALCULATED - this resolves to vec3_origin, but adds some // context indicating that the person writing the code is not allowing // FireBullets() to modify the direction of the shot because the shot direction // being passed into the function has already been modified by another piece of // code and should be fired as specified. See GetActualShotTrajectory(). // NOTE: The way these are calculated is that each component == sin (degrees/2) #define VECTOR_CONE_PRECALCULATED vec3_origin #define VECTOR_CONE_1DEGREES Vector( 0.00873, 0.00873, 0.00873 ) #define VECTOR_CONE_2DEGREES Vector( 0.01745, 0.01745, 0.01745 ) #define VECTOR_CONE_3DEGREES Vector( 0.02618, 0.02618, 0.02618 ) #define VECTOR_CONE_4DEGREES Vector( 0.03490, 0.03490, 0.03490 ) #define VECTOR_CONE_5DEGREES Vector( 0.04362, 0.04362, 0.04362 ) #define VECTOR_CONE_6DEGREES Vector( 0.05234, 0.05234, 0.05234 ) #define VECTOR_CONE_7DEGREES Vector( 0.06105, 0.06105, 0.06105 ) #define VECTOR_CONE_8DEGREES Vector( 0.06976, 0.06976, 0.06976 ) #define VECTOR_CONE_9DEGREES Vector( 0.07846, 0.07846, 0.07846 ) #define VECTOR_CONE_10DEGREES Vector( 0.08716, 0.08716, 0.08716 ) #define VECTOR_CONE_15DEGREES Vector( 0.13053, 0.13053, 0.13053 ) #define VECTOR_CONE_20DEGREES Vector( 0.17365, 0.17365, 0.17365 ) //----------------------------------------------------------------------------- // Purpose: Base weapon class, shared on client and server //----------------------------------------------------------------------------- #if defined USES_ECON_ITEMS #define BASECOMBATWEAPON_DERIVED_FROM CEconEntity #else #define BASECOMBATWEAPON_DERIVED_FROM CBaseAnimating #endif //----------------------------------------------------------------------------- // Collect trace attacks for weapons that fire multiple projectiles per attack that also penetrate //----------------------------------------------------------------------------- class CDmgAccumulator { public: CDmgAccumulator( void ); ~CDmgAccumulator(); #ifdef GAME_DLL virtual void Start( void ) { m_bActive = true; } virtual void AccumulateMultiDamage( const CTakeDamageInfo &info, CBaseEntity *pEntity ); virtual void Process( void ); private: CTakeDamageInfo m_updatedInfo; CUtlMap< int, CTakeDamageInfo > m_TargetsDmgInfo; #endif // GAME_DLL private: bool m_bActive; }; //----------------------------------------------------------------------------- // Purpose: Client side rep of CBaseTFCombatWeapon //----------------------------------------------------------------------------- // Hacky class CBaseCombatWeapon : public BASECOMBATWEAPON_DERIVED_FROM { public: DECLARE_CLASS( CBaseCombatWeapon, BASECOMBATWEAPON_DERIVED_FROM ); DECLARE_NETWORKCLASS(); DECLARE_PREDICTABLE(); CBaseCombatWeapon(); virtual ~CBaseCombatWeapon(); virtual bool IsBaseCombatWeapon( void ) const { return true; } virtual CBaseCombatWeapon *MyCombatWeaponPointer( void ) { return this; } // A derived weapon class should return true here so that weapon sounds, etc, can // apply the proper filter virtual bool IsPredicted( void ) const { return false; } virtual void Spawn( void ); virtual void Precache( void ); void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ); // Subtypes are used to manage multiple weapons of the same type on the player. virtual int GetSubType( void ) { return m_iSubType; } virtual void SetSubType( int iType ) { m_iSubType = iType; } virtual void Equip( CBaseCombatCharacter *pOwner ); virtual void Drop( const Vector &vecVelocity ); virtual int UpdateClientData( CBasePlayer *pPlayer ); virtual bool IsAllowedToSwitch( void ); virtual bool CanBeSelected( void ); virtual bool VisibleInWeaponSelection( void ); virtual bool HasAmmo( void ); // Weapon Pickup For Player virtual void SetPickupTouch( void ); virtual void DefaultTouch( CBaseEntity *pOther ); // default weapon touch virtual void GiveTo( CBaseEntity *pOther ); // HUD Hints virtual bool ShouldDisplayAltFireHUDHint(); virtual void DisplayAltFireHudHint(); virtual void RescindAltFireHudHint(); ///< undisplay the hud hint and pretend it never showed. virtual bool ShouldDisplayReloadHUDHint(); virtual void DisplayReloadHudHint(); virtual void RescindReloadHudHint(); // Weapon client handling virtual void SetViewModelIndex( int index = 0 ); virtual bool SendWeaponAnim( int iActivity ); virtual void SendViewModelAnim( int nSequence ); float GetViewModelSequenceDuration(); // Return how long the current view model sequence is. bool IsViewModelSequenceFinished( void ) const; // Returns if the viewmodel's current animation is finished virtual void SetViewModel(); virtual bool HasWeaponIdleTimeElapsed( void ); virtual void SetWeaponIdleTime( float time ); virtual float GetWeaponIdleTime( void ); // Weapon selection virtual bool HasAnyAmmo( void ); // Returns true is weapon has ammo virtual bool HasPrimaryAmmo( void ); // Returns true is weapon has ammo virtual bool HasSecondaryAmmo( void ); // Returns true is weapon has ammo bool UsesPrimaryAmmo( void ); // returns true if the weapon actually uses primary ammo bool UsesSecondaryAmmo( void ); // returns true if the weapon actually uses secondary ammo void GiveDefaultAmmo( void ); virtual bool CanHolster( void ) const { return TRUE; }; // returns true if the weapon can be holstered virtual bool DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt ); virtual bool CanDeploy( void ) { return true; } // return true if the weapon's allowed to deploy virtual bool Deploy( void ); // returns true is deploy was successful virtual bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL ); virtual CBaseCombatWeapon *GetLastWeapon( void ) { return this; } virtual void SetWeaponVisible( bool visible ); virtual bool IsWeaponVisible( void ); virtual bool ReloadOrSwitchWeapons( void ); virtual void OnActiveStateChanged( int iOldState ) { return; } virtual bool HolsterOnDetach() { return false; } virtual bool IsHolstered(){ return false; } virtual void Detach() {} // Weapon behaviour virtual void ItemPreFrame( void ); // called each frame by the player PreThink virtual void ItemPostFrame( void ); // called each frame by the player PostThink virtual void ItemBusyFrame( void ); // called each frame by the player PostThink, if the player's not ready to attack yet virtual void ItemHolsterFrame( void ) {}; // called each frame by the player PreThink, if the weapon is holstered virtual void WeaponIdle( void ); // called when no buttons pressed virtual void HandleFireOnEmpty(); // Called when they have the attack button down // but they are out of ammo. The default implementation // either reloads, switches weapons, or plays an empty sound. virtual bool CanPerformSecondaryAttack() const; virtual bool ShouldBlockPrimaryFire() { return false; } #ifdef CLIENT_DLL virtual void CreateMove( float flInputSampleTime, CUserCmd *pCmd, const QAngle &vecOldViewAngles ) {} virtual int CalcOverrideModelIndex() OVERRIDE; #endif virtual bool IsWeaponZoomed() { return false; } // Is this weapon in its 'zoomed in' mode? // Reloading virtual void CheckReload( void ); virtual void FinishReload( void ); virtual void AbortReload( void ); virtual bool Reload( void ); bool DefaultReload( int iClipSize1, int iClipSize2, int iActivity ); bool ReloadsSingly( void ) const; virtual bool AutoFiresFullClip( void ) const { return false; } virtual void UpdateAutoFire( void ); // Weapon firing virtual void PrimaryAttack( void ); // do "+ATTACK" virtual void SecondaryAttack( void ) { return; } // do "+ATTACK2" // Firing animations virtual Activity GetPrimaryAttackActivity( void ); virtual Activity GetSecondaryAttackActivity( void ); virtual Activity GetDrawActivity( void ); virtual float GetDefaultAnimSpeed( void ) { return 1.0; } // Bullet launch information virtual int GetBulletType( void ); virtual const Vector& GetBulletSpread( void ); virtual Vector GetBulletSpread( WeaponProficiency_t proficiency ) { return GetBulletSpread(); } virtual float GetSpreadBias( WeaponProficiency_t proficiency ) { return 1.0; } virtual float GetFireRate( void ); virtual int GetMinBurst() { return 1; } virtual int GetMaxBurst() { return 1; } virtual float GetMinRestTime() { return 0.3; } virtual float GetMaxRestTime() { return 0.6; } virtual int GetRandomBurst() { return random->RandomInt( GetMinBurst(), GetMaxBurst() ); } virtual void WeaponSound( WeaponSound_t sound_type, float soundtime = 0.0f ); virtual void StopWeaponSound( WeaponSound_t sound_type ); virtual const WeaponProficiencyInfo_t *GetProficiencyValues(); // Autoaim virtual float GetMaxAutoAimDeflection() { return 0.99f; } virtual float WeaponAutoAimScale() { return 1.0f; } // allows a weapon to influence the perceived size of the target's autoaim radius. // TF Sprinting functions virtual bool StartSprinting( void ) { return false; }; virtual bool StopSprinting( void ) { return false; }; // TF Injury functions virtual float GetDamage( float flDistance, int iLocation ) { return 0.0; }; virtual void SetActivity( Activity act, float duration ); inline void SetActivity( Activity eActivity ) { m_Activity = eActivity; } inline Activity GetActivity( void ) const { return m_Activity; } virtual void AddViewKick( void ); // Add in the view kick for the weapon virtual char *GetDeathNoticeName( void ); // Get the string to print death notices with CBaseCombatCharacter *GetOwner() const; void SetOwner( CBaseCombatCharacter *owner ); virtual void OnPickedUp( CBaseCombatCharacter *pNewOwner ); virtual void AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles ) {}; virtual float CalcViewmodelBob( void ) { return 0.0f; }; // Returns information about the various control panels virtual void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName ); virtual void GetControlPanelClassName( int nPanelIndex, const char *&pPanelName ); virtual bool ShouldShowControlPanels( void ) { return true; } void Lock( float lockTime, CBaseEntity *pLocker ); bool IsLocked( CBaseEntity *pAsker ); //All weapons can be picked up by NPCs by default virtual bool CanBePickedUpByNPCs( void ) { return true; } virtual int GetSkinOverride() const { return -1; } public: // Weapon info accessors for data in the weapon's data file const FileWeaponInfo_t &GetWpnData( void ) const; virtual const char *GetViewModel( int viewmodelindex = 0 ) const; virtual const char *GetWorldModel( void ) const; virtual const char *GetAnimPrefix( void ) const; virtual int GetMaxClip1( void ) const; virtual int GetMaxClip2( void ) const; virtual int GetDefaultClip1( void ) const; virtual int GetDefaultClip2( void ) const; virtual int GetWeight( void ) const; virtual bool AllowsAutoSwitchTo( void ) const; virtual bool AllowsAutoSwitchFrom( void ) const; virtual bool ForceWeaponSwitch( void ) const { return false; } virtual int GetWeaponFlags( void ) const; virtual int GetSlot( void ) const; virtual int GetPosition( void ) const; virtual char const *GetName( void ) const; virtual char const *GetPrintName( void ) const; virtual char const *GetShootSound( int iIndex ) const; virtual int GetRumbleEffect() const; virtual bool UsesClipsForAmmo1( void ) const; virtual bool UsesClipsForAmmo2( void ) const; bool IsMeleeWeapon() const; // derive this function if you mod uses encrypted weapon info files virtual const unsigned char *GetEncryptionKey( void ); virtual int GetPrimaryAmmoType( void ) const { return m_iPrimaryAmmoType; } virtual int GetSecondaryAmmoType( void ) const { return m_iSecondaryAmmoType; } virtual int Clip1() { return m_iClip1; } virtual int Clip2() { return m_iClip2; } // Ammo quantity queries for weapons that do not use clips. These are only // used to determine how much ammo is in a weapon that does not have an owner. // That is, a weapon that's on the ground for the player to get ammo out of. int GetPrimaryAmmoCount() { return m_iPrimaryAmmoCount; } void SetPrimaryAmmoCount( int count ) { m_iPrimaryAmmoCount = count; } int GetSecondaryAmmoCount() { return m_iSecondaryAmmoCount; } void SetSecondaryAmmoCount( int count ) { m_iSecondaryAmmoCount = count; } virtual CHudTexture const *GetSpriteActive( void ) const; virtual CHudTexture const *GetSpriteInactive( void ) const; virtual CHudTexture const *GetSpriteAmmo( void ) const; virtual CHudTexture const *GetSpriteAmmo2( void ) const; virtual CHudTexture const *GetSpriteCrosshair( void ) const; virtual CHudTexture const *GetSpriteAutoaim( void ) const; virtual CHudTexture const *GetSpriteZoomedCrosshair( void ) const; virtual CHudTexture const *GetSpriteZoomedAutoaim( void ) const; virtual Activity ActivityOverride( Activity baseAct, bool *pRequired ); virtual acttable_t* ActivityList( int &iActivityCount ) { return NULL; } virtual void PoseParameterOverride( bool bReset ); virtual poseparamtable_t* PoseParamList( int &iPoseParamCount ) { return NULL; } virtual void Activate( void ); virtual bool ShouldUseLargeViewModelVROverride() { return false; } public: // Server Only Methods #if !defined( CLIENT_DLL ) DECLARE_DATADESC(); virtual void FallInit( void ); // prepare to fall to the ground virtual void FallThink( void ); // make the weapon fall to the ground after spawning // Weapon spawning bool IsConstrained() { return m_pConstraint != NULL; } bool IsInBadPosition ( void ); // Is weapon in bad position to pickup? bool RepositionWeapon ( void ); // Attempts to reposition the weapon in a location where it can be virtual void Materialize( void ); // make a weapon visible and tangible void AttemptToMaterialize( void ); // see if the game rules will let the weapon become visible and tangible virtual void CheckRespawn( void ); // see if this weapon should respawn after being picked up CBaseEntity *Respawn ( void ); // copy a weapon static int GetAvailableWeaponsInBox( CBaseCombatWeapon **pList, int listMax, const Vector &mins, const Vector &maxs ); // Weapon dropping / destruction virtual void Delete( void ); void DestroyItem( void ); virtual void Kill( void ); virtual int CapabilitiesGet( void ) { return 0; } virtual int ObjectCaps( void ); bool IsRemoveable() { return m_bRemoveable; } void SetRemoveable( bool bRemoveable ) { m_bRemoveable = bRemoveable; } // Returns bits for weapon conditions virtual bool WeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions ); virtual int WeaponRangeAttack1Condition( float flDot, float flDist ); virtual int WeaponRangeAttack2Condition( float flDot, float flDist ); virtual int WeaponMeleeAttack1Condition( float flDot, float flDist ); virtual int WeaponMeleeAttack2Condition( float flDot, float flDist ); virtual void Operator_FrameUpdate( CBaseCombatCharacter *pOperator ); virtual void Operator_HandleAnimEvent( animevent_t *pEvent, CBaseCombatCharacter *pOperator ); virtual void Operator_ForceNPCFire( CBaseCombatCharacter *pOperator, bool bSecondary ) { return; } // NOTE: This should never be called when a character is operating the weapon. Animation events should be // routed through the character, and then back into CharacterAnimEvent() void HandleAnimEvent( animevent_t *pEvent ); virtual int UpdateTransmitState( void ); void InputHideWeapon( inputdata_t &inputdata ); void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); virtual CDmgAccumulator *GetDmgAccumulator( void ) { return NULL; } void SetSoundsEnabled( bool bSoundsEnabled ) { m_bSoundsEnabled = bSoundsEnabled; } // Client only methods #else virtual void BoneMergeFastCullBloat( Vector &localMins, Vector &localMaxs, const Vector &thisEntityMins, const Vector &thisEntityMaxs ) const; virtual bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options ) { #if defined USES_ECON_ITEMS return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options ); #else return false; #endif } // Should this object cast shadows? virtual ShadowType_t ShadowCastType(); virtual void SetDormant( bool bDormant ); virtual void OnDataChanged( DataUpdateType_t updateType ); virtual void OnRestore(); virtual void RestartParticleEffect( void ) {} virtual void Redraw(void); virtual void ViewModelDrawn( CBaseViewModel *pViewModel ); // Get the position that bullets are seen coming out. Note: the returned values are different // for first person and third person. bool GetShootPosition( Vector &vOrigin, QAngle &vAngles ); virtual void DrawCrosshair( void ); virtual bool ShouldDrawCrosshair( void ) { return true; } // Weapon state checking virtual bool IsCarriedByLocalPlayer( void ); virtual bool ShouldDrawUsingViewModel( void ); virtual bool IsActiveByLocalPlayer( void ); bool IsBeingCarried() const; // Is the carrier alive? bool IsCarrierAlive() const; // Returns the aiment render origin + angles virtual int DrawModel( int flags ); virtual bool ShouldDraw( void ); virtual bool ShouldDrawPickup( void ); virtual void HandleInput( void ) { return; }; virtual void OverrideMouseInput( float *x, float *y ) { return; }; virtual int KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding ) { return 1; } virtual bool AddLookShift( void ) { return true; }; virtual void GetViewmodelBoneControllers(C_BaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS]) { return; } virtual void NotifyShouldTransmit( ShouldTransmitState_t state ); WEAPON_FILE_INFO_HANDLE GetWeaponFileInfoHandle() { return m_hWeaponFileInfo; } virtual int GetWorldModelIndex( void ); virtual void GetToolRecordingState( KeyValues *msg ); virtual void GetWeaponCrosshairScale( float &flScale ) { flScale = 1.f; } #if !defined USES_ECON_ITEMS // Viewmodel overriding virtual bool ViewModel_IsTransparent( void ) { return IsTransparent(); } virtual bool ViewModel_IsUsingFBTexture( void ) { return UsesPowerOfTwoFrameBufferTexture(); } virtual bool IsOverridingViewmodel( void ) { return false; }; virtual int DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags ) { return 0; }; bool WantsToOverrideViewmodelAttachments( void ) { return false; } #endif #endif // End client-only methods virtual bool CanLower( void ) { return false; } virtual bool Ready( void ) { return false; } virtual bool Lower( void ) { return false; } virtual void HideThink( void ); virtual bool CanReload( void ); private: typedef CHandle< CBaseCombatCharacter > CBaseCombatCharacterHandle; CNetworkVar( CBaseCombatCharacterHandle, m_hOwner ); // Player carrying this weapon protected: #if defined ( TF_CLIENT_DLL ) || defined ( TF_DLL ) // Regulate crit frequency to reduce client-side seed hacking void AddToCritBucket( float flAmount ); void RemoveFromCritBucket( float flAmount ) { m_flCritTokenBucket -= flAmount; } bool IsAllowedToWithdrawFromCritBucket( float flDamage ); float m_flCritTokenBucket; int m_nCritChecks; int m_nCritSeedRequests; #endif // TF public: // Networked fields CNetworkVar( int, m_nViewModelIndex ); // Weapon firing CNetworkVar( float, m_flNextPrimaryAttack ); // soonest time ItemPostFrame will call PrimaryAttack CNetworkVar( float, m_flNextSecondaryAttack ); // soonest time ItemPostFrame will call SecondaryAttack CNetworkVar( float, m_flTimeWeaponIdle ); // soonest time ItemPostFrame will call WeaponIdle // Weapon state bool m_bInReload; // Are we in the middle of a reload; bool m_bFireOnEmpty; // True when the gun is empty and the player is still holding down the attack key(s) bool m_bFiringWholeClip; // Are we in the middle of firing the whole clip; // Weapon art CNetworkVar( int, m_iViewModelIndex ); CNetworkVar( int, m_iWorldModelIndex ); // Sounds float m_flNextEmptySoundTime; // delay on empty sound playing Activity GetIdealActivity( void ) { return m_IdealActivity; } int GetIdealSequence( void ) { return m_nIdealSequence; } bool SetIdealActivity( Activity ideal ); void MaintainIdealActivity( void ); #ifdef CLIENT_DLL virtual const Vector& GetViewmodelOffset() { return vec3_origin; } #endif // CLIENT_DLL private: Activity m_Activity; int m_nIdealSequence; Activity m_IdealActivity; bool m_bRemoveable; int m_iPrimaryAmmoCount; int m_iSecondaryAmmoCount; public: IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_nNextThinkTick ); #ifdef CLIENT_DLL static void RecvProxy_WeaponState( const CRecvProxyData *pData, void *pStruct, void *pOut ); #endif int WeaponState() const { return m_iState; } // Weapon data CNetworkVar( int, m_iState ); // See WEAPON_* definition string_t m_iszName; // Classname of this weapon. CNetworkVar( int, m_iPrimaryAmmoType ); // "primary" ammo index into the ammo info array CNetworkVar( int, m_iSecondaryAmmoType ); // "secondary" ammo index into the ammo info array CNetworkVar( int, m_iClip1 ); // number of shots left in the primary weapon clip, -1 it not used CNetworkVar( int, m_iClip2 ); // number of shots left in the secondary weapon clip, -1 it not used bool m_bFiresUnderwater; // true if this weapon can fire underwater bool m_bAltFiresUnderwater; // true if this weapon can fire underwater float m_fMinRange1; // What's the closest this weapon can be used? float m_fMinRange2; // What's the closest this weapon can be used? float m_fMaxRange1; // What's the furthest this weapon can be used? float m_fMaxRange2; // What's the furthest this weapon can be used? bool m_bReloadsSingly; // True if this weapon reloads 1 round at a time float m_fFireDuration; // The amount of time that the weapon has sustained firing int m_iSubType; float m_flUnlockTime; EHANDLE m_hLocker; // Who locked this weapon. CNetworkVar( bool, m_bFlipViewModel ); IPhysicsConstraint *GetConstraint() { return m_pConstraint; } private: WEAPON_FILE_INFO_HANDLE m_hWeaponFileInfo; IPhysicsConstraint *m_pConstraint; int m_iAltFireHudHintCount; // How many times has this weapon displayed its alt-fire HUD hint? int m_iReloadHudHintCount; // How many times has this weapon displayed its reload HUD hint? bool m_bAltFireHudHintDisplayed; // Have we displayed an alt-fire HUD hint since this weapon was deployed? bool m_bReloadHudHintDisplayed; // Have we displayed a reload HUD hint since this weapon was deployed? float m_flHudHintPollTime; // When to poll the weapon again for whether it should display a hud hint. float m_flHudHintMinDisplayTime; // if the hint is squelched before this, reset my counter so we'll display it again. // Server only #if !defined( CLIENT_DLL ) bool m_bSoundsEnabled; // Outputs protected: COutputEvent m_OnPlayerUse; // Fired when the player uses the weapon. COutputEvent m_OnPlayerPickup; // Fired when the player picks up the weapon. COutputEvent m_OnNPCPickup; // Fired when an NPC picks up the weapon. COutputEvent m_OnCacheInteraction; // For awarding lambda cache achievements in HL2 on 360. See .FGD file for details #else // Client .dll only bool m_bJustRestored; // Allow weapons resource to access m_hWeaponFileInfo directly friend class WeaponsResource; protected: int m_iOldState; #endif // End Client .dll only }; #endif // COMBATWEAPON_SHARED_H