767 lines
29 KiB
C++
767 lines
29 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef COMBATWEAPON_SHARED_H
|
|
#define COMBATWEAPON_SHARED_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "baseviewmodel_shared.h"
|
|
#include "predictable_entity.h"
|
|
#include "sharedInterface.h"
|
|
#include "soundflags.h"
|
|
#include "utlmap.h"
|
|
#include "vphysics_interface.h"
|
|
#include "weapon_parse.h"
|
|
#include "weapon_proficiency.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; }
|
|
|
|
// 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);
|
|
|
|
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)
|
|
|
|
// 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
|