H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-26 08:06:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e4fb69378a
source-engine/game/shared/cstrike/weapon_csbase.cpp

1918 lines
50 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Laser Rifle & Shield combo
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "in_buttons.h"
#include "takedamageinfo.h"
#include "weapon_csbase.h"
#include "ammodef.h"
#include "cs_gamerules.h"
#define ALLOW_WEAPON_SPREAD_DISPLAY 0
#if defined( CLIENT_DLL )
#include "vgui/ISurface.h"
#include "vgui_controls/Controls.h"
#include "c_cs_player.h"
#include "hud_crosshair.h"
#include "c_te_effect_dispatch.h"
#include "c_te_legacytempents.h"
extern IVModelInfoClient* modelinfo;
#else
#include "cs_player.h"
#include "te_effect_dispatch.h"
#include "KeyValues.h"
#include "cs_ammodef.h"
extern IVModelInfo* modelinfo;
#endif
ConVar weapon_accuracy_model( "weapon_accuracy_model", "2", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY | FCVAR_ARCHIVE );
// ----------------------------------------------------------------------------- //
// Global functions.
// ----------------------------------------------------------------------------- //
struct WeaponAliasTranslationInfoStruct
{
const char* alias;
const char* translatedAlias;
};
static const WeaponAliasTranslationInfoStruct s_WeaponAliasTranslationInfo[] =
{
{ "cv47", "ak47" },
{ "defender", "galil" },
{ "krieg552", "sg552" },
{ "magnum", "awp" },
{ "d3au1", "g3sg1" },
{ "clarion", "famas" },
{ "bullpup", "aug" },
{ "krieg550", "sg550" },
{ "9x19mm", "glock" },
{ "km45", "usp" },
{ "228compact", "p228" },
{ "nighthawk", "deagle" },
{ "elites", "elite" },
{ "fn57", "fiveseven" },
{ "12gauge", "m3" },
{ "autoshotgun", "xm1014" },
{ "mp", "tmp" },
{ "smg", "mp5navy" },
{ "mp5", "mp5navy" },
{ "c90", "p90" },
{ "vest", "kevlar" },
{ "vesthelm", "assaultsuit" },
{ "smokegrenade", "sgren" },
{ "smokegrenade", "sgren" },
{ "nvgs", "nightvision" },
{ "", "" } // this needs to be last
};
struct WeaponAliasInfo
{
CSWeaponID id;
const char* alias;
};
WeaponAliasInfo s_weaponAliasInfo[] =
{
{ WEAPON_P228, "p228" },
{ WEAPON_GLOCK, "glock" },
{ WEAPON_SCOUT, "scout" },
{ WEAPON_XM1014, "xm1014" },
{ WEAPON_MAC10, "mac10" },
{ WEAPON_AUG, "aug" },
{ WEAPON_ELITE, "elite" },
{ WEAPON_FIVESEVEN, "fiveseven" },
{ WEAPON_UMP45, "ump45" },
{ WEAPON_SG550, "sg550" },
{ WEAPON_GALIL, "galil" },
{ WEAPON_FAMAS, "famas" },
{ WEAPON_USP, "usp" },
{ WEAPON_AWP, "awp" },
{ WEAPON_MP5NAVY, "mp5navy" },
{ WEAPON_M249, "m249" },
{ WEAPON_M3, "m3" },
{ WEAPON_M4A1, "m4a1" },
{ WEAPON_TMP, "tmp" },
{ WEAPON_G3SG1, "g3sg1" },
{ WEAPON_DEAGLE, "deagle" },
{ WEAPON_SG552, "sg552" },
{ WEAPON_AK47, "ak47" },
{ WEAPON_P90, "p90" },
{ WEAPON_KNIFE, "knife" },
{ WEAPON_C4, "c4" },
{ WEAPON_FLASHBANG, "flashbang" },
{ WEAPON_SMOKEGRENADE, "smokegrenade" },
{ WEAPON_SMOKEGRENADE, "sgren" },
{ WEAPON_HEGRENADE, "hegrenade" },
{ WEAPON_HEGRENADE, "hegren" },
// not sure any of these are needed
{ WEAPON_SHIELDGUN, "shield" },
{ WEAPON_SHIELDGUN, "shieldgun" },
{ WEAPON_KEVLAR, "kevlar" },
{ WEAPON_ASSAULTSUIT, "assaultsuit" },
{ WEAPON_NVG, "nightvision" },
{ WEAPON_NVG, "nvg" },
{ WEAPON_NONE, "none" },
};
bool IsAmmoType( int iAmmoType, const char *pAmmoName )
{
return GetAmmoDef()->Index( pAmmoName ) == iAmmoType;
}
//--------------------------------------------------------------------------------------------------------
//
// Given an alias, return the translated alias.
//
const char * GetTranslatedWeaponAlias( const char *szAlias )
{
for ( int i = 0; i < ARRAYSIZE(s_WeaponAliasTranslationInfo); ++i )
{
if ( Q_stricmp(s_WeaponAliasTranslationInfo[i].alias, szAlias) == 0 )
{
return s_WeaponAliasTranslationInfo[i].translatedAlias;
}
}
return szAlias;
}
//--------------------------------------------------------------------------------------------------------
//
// Given a translated alias, return the alias.
//
const char * GetWeaponAliasFromTranslated(const char *translatedAlias)
{
int i = 0;
const WeaponAliasTranslationInfoStruct *info = &(s_WeaponAliasTranslationInfo[i]);
while (info->alias[0] != 0)
{
if (Q_stricmp(translatedAlias, info->translatedAlias) == 0)
{
return info->alias;
}
info = &(s_WeaponAliasTranslationInfo[++i]);
}
return translatedAlias;
}
//--------------------------------------------------------------------------------------------------------
//
// Given an alias, return the associated weapon ID
//
CSWeaponID AliasToWeaponID( const char *szAlias )
{
if ( szAlias )
{
for ( int i=0; i < ARRAYSIZE(s_weaponAliasInfo); ++i)
{
if ( Q_stricmp( s_weaponAliasInfo[i].alias, szAlias) == 0 )
return s_weaponAliasInfo[i].id;
}
}
return WEAPON_NONE;
}
//--------------------------------------------------------------------------------------------------------
//
// Given a weapon ID, return its alias
//
const char *WeaponIDToAlias( int id )
{
for ( int i=0; i < ARRAYSIZE(s_weaponAliasInfo); ++i)
{
if ( s_weaponAliasInfo[i].id == id )
return s_weaponAliasInfo[i].alias;
}
return NULL;
}
//--------------------------------------------------------------------------------------------------------
//
// Return true if given weapon ID is a primary weapon
//
bool IsPrimaryWeapon( CSWeaponID id )
{
const CCSWeaponInfo* pWeaponInfo = GetWeaponInfo( id );
if ( pWeaponInfo )
{
return pWeaponInfo->iSlot == WEAPON_SLOT_RIFLE;
}
return false;
}
//--------------------------------------------------------------------------------------------------------
//
// Return true if given weapon ID is a secondary weapon
//
bool IsSecondaryWeapon( CSWeaponID id )
{
const CCSWeaponInfo* pWeaponInfo = GetWeaponInfo( id );
if ( pWeaponInfo )
return pWeaponInfo->iSlot == WEAPON_SLOT_PISTOL;
return false;
}
#ifdef CLIENT_DLL
int GetShellForAmmoType( const char *ammoname )
{
if ( !Q_strcmp( BULLET_PLAYER_762MM, ammoname ) )
return CS_SHELL_762NATO;
if ( !Q_strcmp( BULLET_PLAYER_556MM, ammoname ) )
return CS_SHELL_556;
if ( !Q_strcmp( BULLET_PLAYER_338MAG, ammoname ) )
return CS_SHELL_338MAG;
if ( !Q_strcmp( BULLET_PLAYER_BUCKSHOT, ammoname ) )
return CS_SHELL_12GAUGE;
if ( !Q_strcmp( BULLET_PLAYER_57MM, ammoname ) )
return CS_SHELL_57;
// default 9 mm
return CS_SHELL_9MM;
}
#endif
// ----------------------------------------------------------------------------- //
// CWeaponCSBase tables.
// ----------------------------------------------------------------------------- //
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCSBase, DT_WeaponCSBase )
BEGIN_NETWORK_TABLE( CWeaponCSBase, DT_WeaponCSBase )
#if !defined( CLIENT_DLL )
SendPropInt( SENDINFO( m_weaponMode ), 1, SPROP_UNSIGNED ),
SendPropFloat(SENDINFO(m_fAccuracyPenalty) ),
// world weapon models have no aminations
SendPropExclude( "DT_AnimTimeMustBeFirst", "m_flAnimTime" ),
SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
// SendPropExclude( "DT_LocalActiveWeaponData", "m_flTimeWeaponIdle" ),
#else
RecvPropInt( RECVINFO( m_weaponMode ) ),
RecvPropFloat( RECVINFO(m_fAccuracyPenalty)),
#endif
END_NETWORK_TABLE()
#if defined(CLIENT_DLL)
BEGIN_PREDICTION_DATA( CWeaponCSBase )
DEFINE_PRED_FIELD( m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( m_flNextPrimaryAttack, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( m_flNextSecondaryAttack, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
DEFINE_PRED_FIELD( m_bDelayFire, FIELD_BOOLEAN, 0 ),
DEFINE_PRED_FIELD( m_flAccuracy, FIELD_FLOAT, 0 ),
DEFINE_PRED_FIELD( m_weaponMode, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_fAccuracyPenalty, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.00005f ),
END_PREDICTION_DATA()
#endif
LINK_ENTITY_TO_CLASS( weapon_cs_base, CWeaponCSBase );
#ifdef GAME_DLL
BEGIN_DATADESC( CWeaponCSBase )
//DEFINE_FUNCTION( DefaultTouch ),
DEFINE_THINKFUNC( FallThink )
END_DATADESC()
#endif
#if defined( CLIENT_DLL )
ConVar cl_crosshaircolor( "cl_crosshaircolor", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Set crosshair color: 0=green, 1=red, 2=blue, 3=yellow, 4=cyan, 5=custom" );
ConVar cl_dynamiccrosshair( "cl_dynamiccrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enables dynamic crosshair; 0=off, 1=normal behavior (based on actual weapon accuracy), 2=legacy simulated dynamic behavior, 3=legacy simulated static behavior" );
ConVar cl_crosshairspreadscale( "cl_crosshairspreadscale", "0.3", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
ConVar cl_scalecrosshair( "cl_scalecrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable crosshair scaling (deprecated)" );
ConVar cl_crosshairscale( "cl_crosshairscale", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Crosshair scaling factor (deprecated)" );
ConVar cl_crosshairalpha( "cl_crosshairalpha", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshairusealpha( "cl_crosshairusealpha", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshairsize( "cl_crosshairsize", "5", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshairthickness( "cl_crosshairthickness", "0.5", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshairdot( "cl_crosshairdot", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshaircolor_r( "cl_crosshaircolor_r", "50", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshaircolor_g( "cl_crosshaircolor_g", "250", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
ConVar cl_crosshaircolor_b( "cl_crosshaircolor_b", "50", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
#if ALLOW_WEAPON_SPREAD_DISPLAY
ConVar weapon_debug_spread_show( "weapon_debug_spread_show", "0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY, "Enables display of weapon accuracy; 1: show accuracy box, 2: show box with recoil offset" );
ConVar weapon_debug_spread_gap( "weapon_debug_spread_gap", "0.67", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY );
#endif
// [paquin] make sure crosshair scales independent of frame rate
// unless legacy cvar is set
ConVar cl_legacy_crosshair_recoil( "cl_legacy_crosshair_recoil", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable legacy framerate dependent crosshair recoil");
// use old scaling behavior
ConVar cl_legacy_crosshair_scale( "cl_legacy_crosshair_scale", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable legacy crosshair scaling");
void DrawCrosshairRect( int x0, int y0, int x1, int y1, bool bAdditive )
{
if ( bAdditive )
{
vgui::surface()->DrawTexturedRect( x0, y0, x1, y1 );
}
else
{
// Alpha-blended crosshair
vgui::surface()->DrawFilledRect( x0, y0, x1, y1 );
}
}
#endif
// must be included after the above macros
#ifndef CLIENT_DLL
#include "cs_bot.h"
#endif
// ----------------------------------------------------------------------------- //
// CWeaponCSBase implementation.
// ----------------------------------------------------------------------------- //
CWeaponCSBase::CWeaponCSBase()
{
SetPredictionEligible( true );
m_bDelayFire = true;
m_nextPrevOwnerTouchTime = 0.0;
m_prevOwner = NULL;
AddSolidFlags( FSOLID_TRIGGER ); // Nothing collides with these but it gets touches.
#ifdef CLIENT_DLL
m_iCrosshairTextureID = 0;
#else
m_iDefaultExtraAmmo = 0;
#endif
m_fAccuracyPenalty = 0.0f;
m_weaponMode = Primary_Mode;
}
#ifndef CLIENT_DLL
bool CWeaponCSBase::KeyValue( const char *szKeyName, const char *szValue )
{
if ( !BaseClass::KeyValue( szKeyName, szValue ) )
{
if ( FStrEq( szKeyName, "ammo" ) )
{
int bullets = atoi( szValue );
if ( bullets < 0 )
return false;
m_iDefaultExtraAmmo = bullets;
return true;
}
}
return false;
}
#endif
bool CWeaponCSBase::IsPredicted() const
{
return true;
}
bool CWeaponCSBase::IsPistol() const
{
return GetCSWpnData().m_WeaponType == WEAPONTYPE_PISTOL;
}
bool CWeaponCSBase::IsFullAuto() const
{
return GetCSWpnData().m_bFullAuto;
}
bool CWeaponCSBase::PlayEmptySound()
{
//MIKETODO: certain weapons should override this to make it empty:
// C4
// Flashbang
// HE Grenade
// Smoke grenade
CPASAttenuationFilter filter( this );
filter.UsePredictionRules();
if ( IsPistol() )
{
EmitSound( filter, entindex(), "Default.ClipEmpty_Pistol" );
}
else
{
EmitSound( filter, entindex(), "Default.ClipEmpty_Rifle" );
}
return 0;
}
CCSPlayer* CWeaponCSBase::GetPlayerOwner() const
{
return dynamic_cast< CCSPlayer* >( GetOwner() );
}
//=============================================================================
// HPE_BEGIN:
//=============================================================================
//[dwenger] Accessors for the prior owner list
void CWeaponCSBase::AddToPriorOwnerList(CCSPlayer* pPlayer)
{
if ( !IsAPriorOwner( pPlayer ) )
{
// Add player to prior owner list
m_PriorOwners.AddToTail( pPlayer );
}
}
bool CWeaponCSBase::IsAPriorOwner(CCSPlayer* pPlayer)
{
return (m_PriorOwners.Find( pPlayer ) != -1);
}
//=============================================================================
// HPE_END
//=============================================================================
void CWeaponCSBase::SecondaryAttack( void )
{
#ifndef CLIENT_DLL
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
if ( pPlayer->HasShield() == false )
BaseClass::SecondaryAttack();
else
{
pPlayer->SetShieldDrawnState( !pPlayer->IsShieldDrawn() );
if ( pPlayer->IsShieldDrawn() )
SendWeaponAnim( ACT_SHIELD_UP );
else
SendWeaponAnim( ACT_SHIELD_DOWN );
m_flNextSecondaryAttack = gpGlobals->curtime + 0.4;
m_flNextPrimaryAttack = gpGlobals->curtime + 0.4;
}
#endif
}
bool CWeaponCSBase::SendWeaponAnim( int iActivity )
{
#ifdef CS_SHIELD_ENABLED
CCSPlayer *pPlayer = GetPlayerOwner();
if ( pPlayer && pPlayer->HasShield() )
{
CBaseViewModel *vm = pPlayer->GetViewModel( 1 );
if ( vm == NULL )
return false;
vm->SetWeaponModel( SHIELD_VIEW_MODEL, this );
int idealSequence = vm->SelectWeightedSequence( (Activity)iActivity );
if ( idealSequence >= 0 )
{
vm->SendViewModelMatchingSequence( idealSequence );
}
}
#endif
return BaseClass::SendWeaponAnim( iActivity );
}
void CWeaponCSBase::ItemPostFrame()
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
UpdateAccuracyPenalty();
UpdateShieldState();
if ((m_bInReload) && (pPlayer->m_flNextAttack <= gpGlobals->curtime))
{
// complete the reload.
int j = MIN( GetMaxClip1() - m_iClip1, pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) );
// Add them to the clip
m_iClip1 += j;
pPlayer->RemoveAmmo( j, m_iPrimaryAmmoType );
m_bInReload = false;
}
if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
{
if ( pPlayer->HasShield() )
CWeaponCSBase::SecondaryAttack();
else
SecondaryAttack();
pPlayer->m_nButtons &= ~IN_ATTACK2;
}
else if ((pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime ))
{
if ( CSGameRules()->IsFreezePeriod() ) // Can't shoot during the freeze period
return;
if ( pPlayer->m_bIsDefusing )
return;
if ( pPlayer->State_Get() != STATE_ACTIVE )
return;
if ( pPlayer->IsShieldDrawn() )
return;
// we have to reset the FireOnEmpty flag before we can fire on an empty clip
if ( m_iClip1 == 0 && !m_bFireOnEmpty )
return;
// don't repeat fire if this is not a full auto weapon
if ( pPlayer->m_iShotsFired > 0 && !IsFullAuto() )
return;
#if !defined(CLIENT_DLL)
// allow the bots to react to the gunfire
if ( GetCSWpnData().m_WeaponType != WEAPONTYPE_GRENADE )
{
IGameEvent * event = gameeventmanager->CreateEvent( (HasAmmo()) ? "weapon_fire" : "weapon_fire_on_empty" );
if( event )
{
const char *weaponName = STRING( m_iClassname );
if ( strncmp( weaponName, "weapon_", 7 ) == 0 )
{
weaponName += 7;
}
event->SetInt( "userid", pPlayer->GetUserID() );
event->SetString( "weapon", weaponName );
gameeventmanager->FireEvent( event );
}
}
#endif
PrimaryAttack();
}
else if ( pPlayer->m_nButtons & IN_RELOAD && GetMaxClip1() != WEAPON_NOCLIP && !m_bInReload && m_flNextPrimaryAttack < gpGlobals->curtime)
{
// reload when reload is pressed, or if no buttons are down and weapon is empty.
//MIKETODO: add code for shields...
//if ( !FBitSet( m_iWeaponState, WPNSTATE_SHIELD_DRAWN ) )
if ( !pPlayer->IsShieldDrawn() )
{
if ( Reload() )
{
#ifndef CLIENT_DLL
// allow the bots to react to the reload
IGameEvent * event = gameeventmanager->CreateEvent( "weapon_reload" );
if( event )
{
event->SetInt( "userid", pPlayer->GetUserID() );
gameeventmanager->FireEvent( event );
}
#endif
}
}
}
else if ( !(pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) ) )
{
if ( weapon_accuracy_model.GetInt() == 2 )
{
// Fire button not down -- reset the shots fired count
if ( pPlayer->m_iShotsFired > 0 && ( !IsFullAuto() || m_iClip1 == 0 ) )
{
pPlayer->m_iShotsFired = 0;
}
}
// The following code prevents the player from tapping the firebutton repeatedly
// to simulate full auto and retaining the single shot accuracy of single fire
if ( m_bDelayFire )
{
m_bDelayFire = false;
if (pPlayer->m_iShotsFired > 15)
pPlayer->m_iShotsFired = 15;
m_flDecreaseShotsFired = gpGlobals->curtime + 0.4;
}
m_bFireOnEmpty = true;
// if it's a pistol then set the shots fired to 0 after the player releases a button
if ( IsPistol() )
{
pPlayer->m_iShotsFired = 0;
}
else
{
if ( (pPlayer->m_iShotsFired > 0) && (m_flDecreaseShotsFired < gpGlobals->curtime) )
{
m_flDecreaseShotsFired = gpGlobals->curtime + 0.0225;
pPlayer->m_iShotsFired--;
}
}
if ( (!IsUseable() && m_flNextPrimaryAttack < gpGlobals->curtime) )
{
// Intentionally blank -- used to switch weapons here
}
else
{
// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
{
Reload();
return;
}
}
WeaponIdle( );
return;
}
}
void CWeaponCSBase::ItemBusyFrame()
{
UpdateAccuracyPenalty();
BaseClass::ItemBusyFrame();
}
float CWeaponCSBase::GetInaccuracy() const
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return 0.0f;
const CCSWeaponInfo& weaponInfo = GetCSWpnData();
float fMaxSpeed = GetMaxSpeed();
if ( fMaxSpeed == 0.0f )
fMaxSpeed = GetCSWpnData().m_flMaxSpeed;
return m_fAccuracyPenalty +
RemapValClamped(pPlayer->GetAbsVelocity().Length2D(),
fMaxSpeed * CS_PLAYER_SPEED_DUCK_MODIFIER,
fMaxSpeed * 0.95f, // max out at 95% of run speed to avoid jitter near max speed
0.0f, weaponInfo.m_fInaccuracyMove[m_weaponMode]);
}
float CWeaponCSBase::GetSpread() const
{
if ( weapon_accuracy_model.GetInt() == 1 )
return 0.0f;
return GetCSWpnData().m_fSpread[m_weaponMode];
}
float CWeaponCSBase::GetMaxSpeed() const
{
// The weapon should have set this in its constructor.
float flRet = GetCSWpnData().m_flMaxSpeed;
Assert( flRet > 1 );
return flRet;
}
const CCSWeaponInfo &CWeaponCSBase::GetCSWpnData() const
{
const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
const CCSWeaponInfo *pCSInfo;
#ifdef _DEBUG
pCSInfo = dynamic_cast< const CCSWeaponInfo* >( pWeaponInfo );
Assert( pCSInfo );
#else
pCSInfo = static_cast< const CCSWeaponInfo* >( pWeaponInfo );
#endif
return *pCSInfo;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CWeaponCSBase::GetViewModel( int /*viewmodelindex = 0 -- this is ignored in the base class here*/ ) const
{
CCSPlayer *pOwner = GetPlayerOwner();
if ( pOwner == NULL )
return BaseClass::GetViewModel();
if ( pOwner->HasShield() && GetCSWpnData().m_bCanUseWithShield )
return GetCSWpnData().m_szShieldViewModel;
else
return GetWpnData().szViewModel;
return BaseClass::GetViewModel();
}
void CWeaponCSBase::Precache( void )
{
BaseClass::Precache();
#ifdef CS_SHIELD_ENABLED
if ( GetCSWpnData().m_bCanUseWithShield )
{
PrecacheModel( GetCSWpnData().m_szShieldViewModel );
}
#endif
PrecacheScriptSound( "Default.ClipEmpty_Pistol" );
PrecacheScriptSound( "Default.ClipEmpty_Rifle" );
PrecacheScriptSound( "Default.Zoom" );
}
Activity CWeaponCSBase::GetDeployActivity( void )
{
return ACT_VM_DRAW;
}
bool CWeaponCSBase::DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt )
{
// Msg( "deploy %s at %f\n", GetClassname(), gpGlobals->curtime );
CCSPlayer *pOwner = GetPlayerOwner();
if ( !pOwner )
{
return false;
}
pOwner->SetAnimationExtension( szAnimExt );
SetViewModel();
SendWeaponAnim( GetDeployActivity() );
pOwner->SetNextAttack( gpGlobals->curtime + SequenceDuration() );
m_flNextPrimaryAttack = gpGlobals->curtime;
m_flNextSecondaryAttack = gpGlobals->curtime;
SetWeaponVisible( true );
pOwner->SetShieldDrawnState( false );
if ( pOwner->HasShield() == true )
SetWeaponModelIndex( SHIELD_WORLD_MODEL);
else
SetWeaponModelIndex( szWeaponModel );
return true;
}
void CWeaponCSBase::UpdateShieldState( void )
{
//empty by default.
CCSPlayer *pOwner = GetPlayerOwner();
if ( pOwner == NULL )
return;
//ADRIANTODO
//Make the hitbox set switches here!!!
if ( pOwner->HasShield() == false )
{
pOwner->SetShieldDrawnState( false );
//pOwner->SetHitBoxSet( 0 );
return;
}
else
{
//pOwner->SetHitBoxSet( 1 );
}
}
void CWeaponCSBase::SetWeaponModelIndex( const char *pName )
{
m_iWorldModelIndex = modelinfo->GetModelIndex( pName );
}
bool CWeaponCSBase::CanBeSelected( void )
{
if ( !VisibleInWeaponSelection() )
return false;
return true;
}
bool CWeaponCSBase::CanDeploy( void )
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return false;
if ( pPlayer->HasShield() && GetCSWpnData().m_bCanUseWithShield == false )
return false;
return BaseClass::CanDeploy();
}
float CWeaponCSBase::CalculateNextAttackTime( float fCycleTime )
{
float fCurAttack = m_flNextPrimaryAttack;
float fDeltaAttack = gpGlobals->curtime - fCurAttack;
if ( fDeltaAttack < 0 || fDeltaAttack > gpGlobals->interval_per_tick )
{
fCurAttack = gpGlobals->curtime;
}
m_flNextSecondaryAttack = m_flNextPrimaryAttack = fCurAttack + fCycleTime;
return fCurAttack;
}
bool CWeaponCSBase::Holster( CBaseCombatWeapon *pSwitchingTo )
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return false;
if ( pPlayer )
pPlayer->SetFOV( pPlayer, 0 ); // reset the default FOV.
if ( pPlayer )
pPlayer->SetShieldDrawnState( false );
return BaseClass::Holster( pSwitchingTo );
}
bool CWeaponCSBase::Deploy()
{
CCSPlayer *pPlayer = GetPlayerOwner();
#ifdef CLIENT_DLL
m_iAlpha = 80;
if ( pPlayer )
{
pPlayer->m_iLastZoom = 0;
pPlayer->SetFOV( pPlayer, 0 );
}
#else
m_flDecreaseShotsFired = gpGlobals->curtime;
if ( pPlayer )
{
pPlayer->m_iShotsFired = 0;
pPlayer->m_bResumeZoom = false;
pPlayer->m_iLastZoom = 0;
pPlayer->SetFOV( pPlayer, 0 );
}
#endif
m_fAccuracyPenalty = 0.0f;
return BaseClass::Deploy();
}
#ifndef CLIENT_DLL
bool CWeaponCSBase::IsRemoveable()
{
if ( BaseClass::IsRemoveable() == true )
{
if ( m_nextPrevOwnerTouchTime > gpGlobals->curtime )
{
return false;
}
}
return BaseClass::IsRemoveable();
}
#endif
void CWeaponCSBase::Drop(const Vector &vecVelocity)
{
#ifdef CLIENT_DLL
BaseClass::Drop(vecVelocity);
return;
#else
// 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 );
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 );
m_bInReload = false; // stop reloading
SetThink( NULL );
m_nextPrevOwnerTouchTime = gpGlobals->curtime + 0.8f;
m_prevOwner = GetPlayerOwner();
SetTouch(&CWeaponCSBase::DefaultTouch);
IPhysicsObject *pObj = VPhysicsGetObject();
if ( pObj != NULL )
{
AngularImpulse angImp( 200, 200, 200 );
pObj->AddVelocity( &vecVelocity, &angImp );
}
else
{
SetAbsVelocity( vecVelocity );
}
SetNextThink( gpGlobals->curtime );
SetOwnerEntity( NULL );
SetOwner( NULL );
#endif
}
// whats going on here is that if the player drops this weapon, they shouldn't take it back themselves
// for a little while. But if they throw it at someone else, the other player should get it immediately.
void CWeaponCSBase::DefaultTouch(CBaseEntity *pOther)
{
if ((m_prevOwner != NULL) && (pOther == m_prevOwner) && (gpGlobals->curtime < m_nextPrevOwnerTouchTime))
{
return;
}
BaseClass::DefaultTouch(pOther);
}
#if defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose: Draw the weapon's crosshair
//-----------------------------------------------------------------------------
void CWeaponCSBase::DrawCrosshair()
{
if ( !crosshair.GetInt() )
return;
CHudCrosshair *pCrosshair = GET_HUDELEMENT( CHudCrosshair );
if ( !pCrosshair )
return;
// clear crosshair
pCrosshair->SetCrosshair( 0, Color( 255, 255, 255, 255 ) );
CCSPlayer* pPlayer = (CCSPlayer*)C_BasePlayer::GetLocalPlayer();
if ( !pPlayer )
return;
// localplayer must be owner if not in Spec mode
Assert( (pPlayer == GetPlayerOwner()) || ( pPlayer->GetObserverMode()==OBS_MODE_IN_EYE) );
// Draw the targeting zone around the pCrosshair
if ( pPlayer->IsInVGuiInputMode() )
return;
int r, g, b;
switch ( cl_crosshaircolor.GetInt() )
{
case 0 : r = 50; g = 250; b = 50; break;
case 1 : r = 250; g = 50; b = 50; break;
case 2 : r = 50; g = 50; b = 250; break;
case 3 : r = 250; g = 250; b = 50; break;
case 4 : r = 50; g = 250; b = 250; break;
case 5 :
r = cl_crosshaircolor_r.GetInt();
g = cl_crosshaircolor_g.GetInt();
b = cl_crosshaircolor_b.GetInt();
break;
default : r = 50; g = 250; b = 50; break;
}
// if user is using nightvision, make the crosshair red.
if (pPlayer->m_bNightVisionOn)
{
r = 250;
g = 50;
b = 50;
}
int alpha = clamp( cl_crosshairalpha.GetInt(), 0, 255 );
vgui::surface()->DrawSetColor( r, g, b, alpha );
if ( !m_iCrosshairTextureID )
{
CHudTexture *pTexture = gHUD.GetIcon( "whiteAdditive" );
if ( pTexture )
{
m_iCrosshairTextureID = pTexture->textureId;
}
}
bool bAdditive = !cl_crosshairusealpha.GetBool() && !pPlayer->m_bNightVisionOn;
if ( bAdditive )
{
vgui::surface()->DrawSetColor( r, g, b, 200 );
vgui::surface()->DrawSetTexture( m_iCrosshairTextureID );
}
if ( pPlayer->HasShield() && pPlayer->IsShieldDrawn() == true )
return;
// no crosshair for sniper rifles
bool bCrosshairVisible = crosshair.GetBool() && GetCSWpnData().m_WeaponType != WEAPONTYPE_SNIPER_RIFLE;
if ( !bCrosshairVisible
#if ALLOW_WEAPON_SPREAD_DISPLAY
&& !weapon_debug_spread_show.GetBool()
#endif
)
return;
float fHalfFov = DEG2RAD(pPlayer->GetFOV()) * 0.5f;
int iCrosshairDistance;
int iBarSize = RoundFloatToInt(YRES(cl_crosshairsize.GetFloat()));
int iBarThickness = MAX( 1, RoundFloatToInt(YRES(cl_crosshairthickness.GetFloat())));
switch ( cl_dynamiccrosshair.GetInt() )
{
case 0:
default:
{
// static crosshair
float fSpread = (GetCSWpnData().m_fSpread[m_weaponMode] + GetCSWpnData().m_fInaccuracyStand[m_weaponMode]) * 320.0f / tanf(fHalfFov);
iCrosshairDistance = MAX( 0, RoundFloatToInt( YRES( fSpread * cl_crosshairspreadscale.GetFloat() ) ) );
}
break;
case 1:
{
float fSpread = (GetInaccuracy() + GetSpread()) * 320.0f / tanf(fHalfFov);
iCrosshairDistance = MAX( 0, RoundFloatToInt( YRES( fSpread * cl_crosshairspreadscale.GetFloat() ) ) );
}
break;
case 2:
case 3:
{
float fCrosshairDistanceGoal = GetCSWpnData().m_iCrosshairMinDistance; // The minimum distance the crosshair can achieve...
// legacy dynamic crosshair
if ( cl_dynamiccrosshair.GetInt() == 2 )
{
if ( !( pPlayer->GetFlags() & FL_ONGROUND ) )
fCrosshairDistanceGoal *= 2.0f;
else if ( pPlayer->GetFlags() & FL_DUCKING )
fCrosshairDistanceGoal *= 0.5f;
else if ( pPlayer->GetAbsVelocity().Length() > 100 )
fCrosshairDistanceGoal *= 1.5f;
}
// [jpaquin] changed to only bump up the crosshair size if the player is still shooting or is spectating someone else
int iDeltaDistance = GetCSWpnData().m_iCrosshairDeltaDistance; // Amount by which the crosshair expands when shooting (per frame)
if ( pPlayer->m_iShotsFired > m_iAmmoLastCheck && (pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2)) )
fCrosshairDistanceGoal += iDeltaDistance;
m_iAmmoLastCheck = pPlayer->m_iShotsFired;
if ( m_flCrosshairDistance > fCrosshairDistanceGoal )
{
// [jpaquin] if we're not in legacy crosshair mode, use an exponential decay function so
// that the crosshair shrinks at the same rate regardless of the frame rate
if ( !cl_legacy_crosshair_recoil.GetBool() )
{
// .44888 on the next line makes the decay very close to what old method produces at 100fps.
m_flCrosshairDistance = Lerp(expf(-gpGlobals->frametime / 0.44888f), fCrosshairDistanceGoal, m_flCrosshairDistance);
}
else
{
m_flCrosshairDistance -= 0.1f + m_flCrosshairDistance * 0.013;
}
}
// clamp max crosshair expansion
m_flCrosshairDistance = clamp(m_flCrosshairDistance, fCrosshairDistanceGoal, 25.0f);
if ( cl_legacy_crosshair_scale.GetBool() )
{
//scale bar size to the resolution
int crosshairScale = cl_crosshairscale.GetInt();
if ( crosshairScale < 1 )
{
if ( ScreenHeight() <= 600 )
{
crosshairScale = 600;
}
else if ( ScreenHeight() <= 768 )
{
crosshairScale = 768;
}
else
{
crosshairScale = 1200;
}
}
float scale;
if( cl_scalecrosshair.GetBool() == false )
{
scale = 1.0f;
}
else
{
scale = (float)ScreenHeight() / (float)crosshairScale;
}
// calculate the inner distance of the crosshair in current screen units
iCrosshairDistance = (int)ceil( m_flCrosshairDistance * scale );
iBarSize = XRES(5); // + (iCrosshairDistance - fCrosshairDistanceGoal) / 2;
iBarSize = MAX( 1, (int)( (float)iBarSize * scale ) );
iBarThickness = MAX( 1, (int)floor( scale + 0.5f ) );
}
else
{
iCrosshairDistance = RoundFloatToInt(m_flCrosshairDistance * ScreenHeight() / 1200.0f);
}
}
break;
}
int iCenterX = ScreenWidth() / 2;
int iCenterY = ScreenHeight() / 2;
if ( bCrosshairVisible )
{
// draw horizontal crosshair lines
int iInnerLeft = iCenterX - iCrosshairDistance - iBarThickness / 2;
int iInnerRight = iInnerLeft + 2 * iCrosshairDistance + iBarThickness;
int iOuterLeft = iInnerLeft - iBarSize;
int iOuterRight = iInnerRight + iBarSize;
int y0 = iCenterY - iBarThickness / 2;
int y1 = y0 + iBarThickness;
DrawCrosshairRect( iOuterLeft, y0, iInnerLeft, y1, bAdditive );
DrawCrosshairRect( iInnerRight, y0, iOuterRight, y1, bAdditive );
// draw vertical crosshair lines
int iInnerTop = iCenterY - iCrosshairDistance - iBarThickness / 2;
int iInnerBottom = iInnerTop + 2 * iCrosshairDistance + iBarThickness;
int iOuterTop = iInnerTop - iBarSize;
int iOuterBottom = iInnerBottom + iBarSize;
int x0 = iCenterX - iBarThickness / 2;
int x1 = x0 + iBarThickness;
DrawCrosshairRect( x0, iOuterTop, x1, iInnerTop, bAdditive );
DrawCrosshairRect( x0, iInnerBottom, x1, iOuterBottom, bAdditive );
// draw dot
if ( cl_crosshairdot.GetBool() )
{
int x0 = iCenterX - iBarThickness / 2;
int x1 = x0 + iBarThickness;
int y0 = iCenterY - iBarThickness / 2;
int y1 = y0 + iBarThickness;
DrawCrosshairRect( x0, y0, x1, y1, bAdditive );
}
}
#if ALLOW_WEAPON_SPREAD_DISPLAY
// show accuracy brackets
if ( weapon_debug_spread_show.GetInt() == 1 || weapon_debug_spread_show.GetInt() == 2 )
{
if ( weapon_debug_spread_show.GetInt() == 2 )
{
const QAngle& punchAngles = pPlayer->GetPunchAngle();
Vector vecDirShooting;
AngleVectors( punchAngles, &vecDirShooting );
float iOffsetX = RoundFloatToInt(YRES(vecDirShooting.y * 320.0f / tanf(fHalfFov)));
float iOffsetY = RoundFloatToInt(YRES(vecDirShooting.z * 320.0f / tanf(fHalfFov)));
iCenterX -= iOffsetX;
iCenterY -= iOffsetY;
}
// colors
r = 250;
g = 250;
b = 50;
vgui::surface()->DrawSetColor( r, g, b, alpha );
int iBarThickness = MAX( 1, RoundFloatToInt(YRES(cl_crosshairthickness.GetFloat())));
float fSpreadDistance = (GetInaccuracy() + GetSpread()) * 320.0f / tanf(fHalfFov);
int iSpreadDistance = RoundFloatToInt(YRES(fSpreadDistance));
// draw vertical spread lines
int iInnerLeft = iCenterX - iSpreadDistance;
int iInnerRight = iCenterX + iSpreadDistance;
int iOuterLeft = iInnerLeft - iBarThickness;
int iOuterRight = iInnerRight + iBarThickness;
int iInnerTop = iCenterY - iSpreadDistance;
int iInnerBottom = iCenterY + iSpreadDistance;
int iOuterTop = iInnerTop - iBarThickness;
int iOuterBottom = iInnerBottom + iBarThickness;
int iGap = RoundFloatToInt(weapon_debug_spread_gap.GetFloat() * iSpreadDistance);
// draw horizontal lines
DrawCrosshairRect( iOuterLeft, iOuterTop, iCenterX - iGap, iInnerTop, bAdditive );
DrawCrosshairRect( iCenterX + iGap, iOuterTop, iOuterRight, iInnerTop, bAdditive );
DrawCrosshairRect( iOuterLeft, iInnerBottom, iCenterX - iGap, iOuterBottom, bAdditive );
DrawCrosshairRect( iCenterX + iGap, iInnerBottom, iOuterRight, iOuterBottom, bAdditive );
// draw vertical lines
DrawCrosshairRect( iOuterLeft, iOuterTop, iInnerLeft, iCenterY - iGap, bAdditive );
DrawCrosshairRect( iOuterLeft, iCenterY + iGap, iInnerLeft, iOuterBottom, bAdditive );
DrawCrosshairRect( iInnerRight, iOuterTop, iOuterRight, iCenterY - iGap, bAdditive );
DrawCrosshairRect( iInnerRight, iCenterY + iGap, iOuterRight, iOuterBottom, bAdditive );
}
#endif
}
void CWeaponCSBase::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( GetPredictable() && !ShouldPredict() )
ShutdownPredictable();
}
bool CWeaponCSBase::ShouldPredict()
{
if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
return true;
return BaseClass::ShouldPredict();
}
void CWeaponCSBase::ProcessMuzzleFlashEvent()
{
// This is handled from the player's animstate, so it can match up to the beginning of the fire animation
}
bool CWeaponCSBase::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
{
if( event == 5001 )
{
C_CSPlayer *pPlayer = ToCSPlayer( GetOwner() );
if( pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed() )
return true;
CEffectData data;
data.m_fFlags = 0;
data.m_hEntity = pViewModel->GetRefEHandle();
data.m_nAttachmentIndex = 1;
data.m_flScale = GetCSWpnData().m_flMuzzleScale;
switch( GetMuzzleFlashStyle() )
{
case CS_MUZZLEFLASH_NONE:
break;
case CS_MUZZLEFLASH_X:
{
DispatchEffect( "CS_MuzzleFlash_X", data );
}
break;
case CS_MUZZLEFLASH_NORM:
default:
{
DispatchEffect( "CS_MuzzleFlash", data );
}
break;
}
return true;
}
return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
}
int CWeaponCSBase::GetMuzzleFlashStyle( void )
{
return GetCSWpnData().m_iMuzzleFlashStyle;
}
int CWeaponCSBase::GetMuzzleAttachment( void )
{
return LookupAttachment( "muzzle_flash" );
}
#else
//-----------------------------------------------------------------------------
// Purpose: Get the accuracy derived from weapon and player, and return it
//-----------------------------------------------------------------------------
const Vector& CWeaponCSBase::GetBulletSpread()
{
static Vector cone = VECTOR_CONE_8DEGREES;
return cone;
}
//-----------------------------------------------------------------------------
// Purpose: Match the anim speed to the weapon speed while crouching
//-----------------------------------------------------------------------------
float CWeaponCSBase::GetDefaultAnimSpeed()
{
return 1.0;
}
//-----------------------------------------------------------------------------
// Purpose: Draw the laser rifle effect
//-----------------------------------------------------------------------------
void CWeaponCSBase::BulletWasFired( const Vector &vecStart, const Vector &vecEnd )
{
}
bool CWeaponCSBase::ShouldRemoveOnRoundRestart()
{
if ( GetPlayerOwner() )
return false;
else
return true;
}
//=============================================================================
// HPE_BEGIN:
// [dwenger] Handle round restart processing for the weapon.
//=============================================================================
void CWeaponCSBase::OnRoundRestart()
{
// Clear out the list of prior owners
m_PriorOwners.RemoveAll();
}
//=============================================================================
// HPE_END
//=============================================================================
//=========================================================
// Materialize - make a CWeaponCSBase visible and tangible
//=========================================================
void CWeaponCSBase::Materialize()
{
if ( IsEffectActive( EF_NODRAW ) )
{
// changing from invisible state to visible.
RemoveEffects( EF_NODRAW );
DoMuzzleFlash();
}
AddSolidFlags( FSOLID_TRIGGER );
//SetTouch( &CWeaponCSBase::DefaultTouch );
SetThink( NULL );
}
//=========================================================
// AttemptToMaterialize - the item is trying to rematerialize,
// should it do so now or wait longer?
//=========================================================
void CWeaponCSBase::AttemptToMaterialize()
{
float time = g_pGameRules->FlWeaponTryRespawn( this );
if ( time == 0 )
{
Materialize();
return;
}
SetNextThink( gpGlobals->curtime + time );
}
//=========================================================
// CheckRespawn - a player is taking this weapon, should
// it respawn?
//=========================================================
void CWeaponCSBase::CheckRespawn()
{
//GOOSEMAN : Do not respawn weapons!
return;
}
//=========================================================
// Respawn- this item is already in the world, but it is
// invisible and intangible. Make it visible and tangible.
//=========================================================
CBaseEntity* CWeaponCSBase::Respawn()
{
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
// will decide when to make the weapon visible and touchable.
CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetAbsAngles(), GetOwner() );
if ( pNewWeapon )
{
pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
pNewWeapon->SetTouch( NULL );// no touch
pNewWeapon->SetThink( &CWeaponCSBase::AttemptToMaterialize );
UTIL_DropToFloor( this, MASK_SOLID );
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
// but when it should respawn is based on conditions belonging to the weapon that was taken.
pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
}
else
{
Msg( "Respawn failed to create %s!\n", GetClassname() );
}
return pNewWeapon;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCSBase::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
CBasePlayer *pPlayer = ToBasePlayer( pActivator );
if ( pPlayer )
{
m_OnPlayerUse.FireOutput( pActivator, pCaller );
}
}
bool CWeaponCSBase::Reload()
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return false;
pPlayer->m_iShotsFired = 0;
bool retval = BaseClass::Reload();
return retval;
}
void CWeaponCSBase::Spawn()
{
BaseClass::Spawn();
// Override the bloat that our base class sets as it's a little bit bigger than we want.
// If it's too big, you drop a weapon and its box is so big that you're still touching it
// when it falls and you pick it up again right away.
CollisionProp()->UseTriggerBounds( true, 30 );
// Set this here to allow players to shoot dropped weapons
SetCollisionGroup( COLLISION_GROUP_WEAPON );
SetExtraAmmoCount( m_iDefaultExtraAmmo ); //Start with no additional ammo
m_nextPrevOwnerTouchTime = 0.0;
m_prevOwner = NULL;
//=============================================================================
// HPE_BEGIN:
//=============================================================================
// [tj] initialize donor of this weapon
m_donor = NULL;
m_donated = false;
m_weaponMode = Primary_Mode;
//=============================================================================
// HPE_END
//=============================================================================
}
bool CWeaponCSBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
{
if ( BaseClass::DefaultReload( iClipSize1, iClipSize2, iActivity ) )
{
SendReloadEvents();
return true;
}
else
{
return false;
}
}
void CWeaponCSBase::SendReloadEvents()
{
CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( GetOwner() );
if ( !pPlayer )
return;
// Send a message to any clients that have this entity to play the reload.
CPASFilter filter( pPlayer->GetAbsOrigin() );
filter.RemoveRecipient( pPlayer );
UserMessageBegin( filter, "ReloadEffect" );
WRITE_SHORT( pPlayer->entindex() );
MessageEnd();
// Make the player play his reload animation.
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
}
#endif
bool CWeaponCSBase::DefaultPistolReload()
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return false;
if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
return true;
if ( !DefaultReload( GetCSWpnData().iDefaultClip1, 0, ACT_VM_RELOAD ) )
return false;
pPlayer->m_iShotsFired = 0;
return true;
}
bool CWeaponCSBase::IsUseable()
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return false;
if ( Clip1() <= 0 )
{
if ( pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 && GetMaxClip1() != -1 )
{
// clip is empty (or nonexistant) and the player has no more ammo of this type.
return false;
}
}
return true;
}
#if defined( CLIENT_DLL )
float g_lateralBob = 0;
float g_verticalBob = 0;
static ConVar cl_bobcycle( "cl_bobcycle","0.8", FCVAR_CHEAT );
static ConVar cl_bob( "cl_bob","0.002", FCVAR_CHEAT );
static ConVar cl_bobup( "cl_bobup","0.5", FCVAR_CHEAT );
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CWeaponCSBase::CalcViewmodelBob( void )
{
static float bobtime;
static float lastbobtime;
static float lastspeed;
float cycle;
CBasePlayer *player = ToBasePlayer( GetOwner() );
//Assert( player );
//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
if ( ( !gpGlobals->frametime ) ||
( player == NULL ) ||
( cl_bobcycle.GetFloat() <= 0.0f ) ||
( cl_bobup.GetFloat() <= 0.0f ) ||
( cl_bobup.GetFloat() >= 1.0f ) )
{
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;// just use old value
}
//Find the speed of the player
float speed = player->GetLocalVelocity().Length2D();
float flmaxSpeedDelta = MAX( 0, (gpGlobals->curtime - lastbobtime) * 320.0f );
// don't allow too big speed changes
speed = clamp( speed, lastspeed-flmaxSpeedDelta, lastspeed+flmaxSpeedDelta );
speed = clamp( speed, -320, 320 );
lastspeed = speed;
//FIXME: This maximum speed value must come from the server.
// MaxSpeed() is not sufficient for dealing with sprinting - jdw
float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
bobtime += ( gpGlobals->curtime - lastbobtime ) * bob_offset;
lastbobtime = gpGlobals->curtime;
//Calculate the vertical bob
cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
cycle /= cl_bobcycle.GetFloat();
if ( cycle < cl_bobup.GetFloat() )
{
cycle = M_PI * cycle / cl_bobup.GetFloat();
}
else
{
cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
}
g_verticalBob = speed*0.005f;
g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
g_verticalBob = clamp( g_verticalBob, -7.0f, 4.0f );
//Calculate the lateral bob
cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat()*2)*cl_bobcycle.GetFloat()*2;
cycle /= cl_bobcycle.GetFloat()*2;
if ( cycle < cl_bobup.GetFloat() )
{
cycle = M_PI * cycle / cl_bobup.GetFloat();
}
else
{
cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
}
g_lateralBob = speed*0.005f;
g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
g_lateralBob = clamp( g_lateralBob, -7.0f, 4.0f );
//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &origin -
// &angles -
// viewmodelindex -
//-----------------------------------------------------------------------------
void CWeaponCSBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
{
Vector forward, right;
AngleVectors( angles, &forward, &right, NULL );
CalcViewmodelBob();
// Apply bob, but scaled down to 40%
VectorMA( origin, g_verticalBob * 0.4f, forward, origin );
// Z bob a bit more
origin[2] += g_verticalBob * 0.1f;
// bob the angles
angles[ ROLL ] += g_verticalBob * 0.5f;
angles[ PITCH ] -= g_verticalBob * 0.4f;
angles[ YAW ] -= g_lateralBob * 0.3f;
// VectorMA( origin, g_lateralBob * 0.2f, right, origin );
}
#else
void CWeaponCSBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
{
}
float CWeaponCSBase::CalcViewmodelBob( void )
{
return 0.0f;
}
#endif
#ifndef CLIENT_DLL
bool CWeaponCSBase::PhysicsSplash( const Vector &centerPoint, const Vector &normal, float rawSpeed, float scaledSpeed )
{
if ( rawSpeed > 20 )
{
float size = 4.0f;
if ( !IsPistol() )
size += 2.0f;
// adjust splash size based on speed
size += RemapValClamped( rawSpeed, 0, 400, 0, 3 );
CEffectData data;
data.m_vOrigin = centerPoint;
data.m_vNormal = normal;
data.m_flScale = random->RandomFloat( size, size + 1.0f );
if ( GetWaterType() & CONTENTS_SLIME )
{
data.m_fFlags |= FX_WATER_IN_SLIME;
}
DispatchEffect( "gunshotsplash", data );
return true;
}
return false;
}
#endif // !CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pPicker -
//-----------------------------------------------------------------------------
void CWeaponCSBase::OnPickedUp( CBaseCombatCharacter *pNewOwner )
{
#if !defined( CLIENT_DLL )
RemoveEffects( EF_ITEM_BLINK );
if( pNewOwner->IsPlayer() && pNewOwner->IsAlive() )
{
m_OnPlayerPickup.FireOutput(pNewOwner, this);
// Play the pickup sound for 1st-person observers
CRecipientFilter filter;
for ( int i=0; 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 );
}
// Someone picked me up, so make it so that I can't be removed.
SetRemoveable( false );
#endif
}
void CWeaponCSBase::UpdateAccuracyPenalty()
{
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
const CCSWeaponInfo& weaponInfo = GetCSWpnData();
float fNewPenalty = 0.0f;
// on ladder?
if ( pPlayer->GetMoveType() == MOVETYPE_LADDER )
{
fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode] + weaponInfo.m_fInaccuracyLadder[m_weaponMode];
}
// in the air?
// else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
// {
// fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode] + weaponInfo.m_fInaccuracyJump[m_weaponMode];
// }
else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING) )
{
fNewPenalty += weaponInfo.m_fInaccuracyCrouch[m_weaponMode];
}
else
{
fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode];
}
if ( m_bInReload )
{
fNewPenalty += weaponInfo.m_fInaccuracyReload;
}
if ( fNewPenalty > m_fAccuracyPenalty )
{
m_fAccuracyPenalty = fNewPenalty;
}
else
{
float fDecayFactor;
if ( pPlayer->GetMoveType() == MOVETYPE_LADDER )
{
fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeStand;
}
else if ( !FBitSet(pPlayer->GetFlags(), FL_ONGROUND) ) // in air
{
// enforce a large recovery speed penalty (300%) for players in the air; this helps to provide
// comparable in-air accuracy to the old weapon model
fDecayFactor = logf(10.0f) / (weaponInfo.m_fRecoveryTimeCrouch * 3.0f);
}
else if ( FBitSet(pPlayer->GetFlags(), FL_DUCKING) )
{
fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeCrouch;
}
else
{
fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeStand;
}
m_fAccuracyPenalty = Lerp(expf(TICK_INTERVAL * -fDecayFactor), fNewPenalty, (float)m_fAccuracyPenalty);
}
}
const float kJumpVelocity = sqrtf(2.0f * 800.0f * 57.0f); // see CCSGameMovement::CheckJumpButton()
void CWeaponCSBase::OnJump( float fImpulse )
{
m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyJump[m_weaponMode] * fImpulse / kJumpVelocity;
}
void CWeaponCSBase::OnLand( float fVelocity )
{
float fPenalty = GetCSWpnData().m_fInaccuracyLand[m_weaponMode] * fVelocity / kJumpVelocity;
m_fAccuracyPenalty += fPenalty;
/*
// this bit of code is only if we want to punch the player view on all landings
CCSPlayer *pPlayer = GetPlayerOwner();
if ( !pPlayer )
return;
QAngle angle = pPlayer->GetPunchAngle();
float fVKick = RAD2DEG(asinf(fPenalty)) * 0.4f;
float fHKick = SharedRandomFloat("LandPunchAngleYaw", -1.0f, +1.0f) * fVKick * 0.1f;
angle.x += fVKick; // pitch
angle.y += fHKick; // yaw
pPlayer->SetPunchAngle( angle );
*/
}
Reference in New Issue Copy Permalink