You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1917 lines
50 KiB
1917 lines
50 KiB
//========= 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 ¢erPoint, 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 ); |
|
*/ |
|
}
|
|
|