960 lines
24 KiB
Plaintext
960 lines
24 KiB
Plaintext
/************************************************************************************
|
|
|
|
************************************************************************************/
|
|
|
|
object weapon_base {
|
|
boolean WEAPON_ATTACK;
|
|
boolean WEAPON_ALTFIRE;
|
|
boolean WEAPON_RELOAD;
|
|
boolean WEAPON_RAISEWEAPON;
|
|
boolean WEAPON_LOWERWEAPON;
|
|
boolean WEAPON_MODESWITCH;
|
|
boolean WEAPON_HIDE;
|
|
|
|
void init();
|
|
void preinit();
|
|
void destroy();
|
|
|
|
boolean CanRemove( float amount );
|
|
void Remove( float amount );
|
|
|
|
void WeaponBase_CheckProficiency();
|
|
void UpdateSpreadModifiers();
|
|
float GetFovSpread();
|
|
boolean DisableSpread() { return false; }
|
|
|
|
void RemoveLocalIronSightsEffects();
|
|
void AddLocalIronSightsEffects();
|
|
|
|
void PlayIdleAnim();
|
|
void PlayZoomInAnim();
|
|
void PlayZoomOutAnim();
|
|
void PlayStartSprintAnim();
|
|
void PlayLeaveSprintAnim( string newState, float blend );
|
|
|
|
void OnBecomeViewWeapon();
|
|
void OnFinishViewWeapon();
|
|
|
|
void FreeScopeGUI() { ; }
|
|
void LoadScopeGUI() { ; }
|
|
|
|
boolean ShouldRunGuis();
|
|
|
|
void vCheckProficiency();
|
|
|
|
void UseAmmo_Stroyent( float modIndex );
|
|
void UseAmmo( float modIndex );
|
|
boolean CanReload() { return false; }
|
|
boolean NeedsReload() { return false; }
|
|
|
|
void DisableIronSights_Private( boolean allowWait );
|
|
void EnableIronSights_Private( boolean allowWait );
|
|
void DisableIronSights();
|
|
void EnableIronSights();
|
|
void ToggleIronSights();
|
|
void CheckIronSights();
|
|
void CreateIronSightsThread();
|
|
void IronSightsThread();
|
|
void StopIronSightsThread();
|
|
|
|
void OnNetworkReload();
|
|
|
|
void LaunchProjectile( float modIndex, float projectileIndex );
|
|
void LaunchProjectile_Stroyent( float modIndex, float projectileIndex );
|
|
void AmmoCheckClip( float modIndex );
|
|
void AmmoCheck( float modIndex );
|
|
void PlayFireSound();
|
|
void StopFireSound();
|
|
void DestroySound();
|
|
void HideSights();
|
|
void ShowSights();
|
|
void ShowCrosshair();
|
|
void HideCrosshair();
|
|
void UpdateCharge();
|
|
void StartCooling();
|
|
void FinishCooling();
|
|
void PlayFireEffect();
|
|
|
|
void OnProxyEnter();
|
|
void OnProxyExit();
|
|
|
|
void OnIronSightsEnabled() { ; }
|
|
void OnIronSightsDisabled() { ; }
|
|
|
|
void KillUpdateHeat();
|
|
void CreateUpdateHeat();
|
|
void UpdateHeat();
|
|
|
|
void HideUseCount();
|
|
void ShowUseCount();
|
|
|
|
void Base_OnProxyEnter();
|
|
void Base_OnProxyExit();
|
|
|
|
void Base_BeginReload();
|
|
void Base_EndReload();
|
|
|
|
boolean HasNoAmmo();
|
|
|
|
void Base_Raise();
|
|
void Raise() { Base_Raise(); }
|
|
void DoRaise( string newState, float blend );
|
|
void Base_Lower();
|
|
void Lower() { Base_Lower(); }
|
|
void LeaveSprint( string newState, float blend );
|
|
void Sprint();
|
|
|
|
void Reload() {}
|
|
|
|
void AddHeat();
|
|
boolean IsOverheated();
|
|
|
|
void UpdateCrosshair();
|
|
void SetCrosshair();
|
|
|
|
boolean AllowLocalMuzzleFlash();
|
|
|
|
float chargePerUse;
|
|
float fireRate;
|
|
float fovSpeed;
|
|
float fovSpread;
|
|
float fovTime;
|
|
float fovZoom;
|
|
float lowAmmo;
|
|
float lowAmmoWarn;
|
|
float numModes;
|
|
float numProjectiles;
|
|
float range;
|
|
float reFire;
|
|
float reloadAmmo;
|
|
boolean sightsHidden;
|
|
float speedMod;
|
|
float triggerDelay;
|
|
float spreadModifier;
|
|
|
|
float overheatLength;
|
|
float overheatPerShot;
|
|
float heatTimerHandle;
|
|
|
|
player myPlayer;
|
|
|
|
boolean altFireDown;
|
|
boolean mainFireDown;
|
|
boolean modeSwitchDown;
|
|
boolean isCooling;
|
|
boolean showAllAmmo;
|
|
boolean showClip;
|
|
boolean hideAmmo;
|
|
boolean showCharge;
|
|
boolean needsAmmoBox;
|
|
|
|
boolean localIronSightsEffectsActive;
|
|
boolean localIronSightsEffectsEnabled;
|
|
|
|
boolean ironSightsEnabled;
|
|
float ironSightsTimeout;
|
|
boolean wantsIronSights;
|
|
boolean ironSightsThreadActive;
|
|
|
|
boolean hideCrosshair;
|
|
boolean secondaryCrosshair;
|
|
|
|
boolean noEnergySegments;
|
|
|
|
boolean GetIronSightsStatus() { return ironSightsEnabled; }
|
|
|
|
void StartIdleEffect();
|
|
void StopIdleEffect();
|
|
boolean idleEffectOn;
|
|
string idleEffectJoint;
|
|
|
|
string crosshairPrimary;
|
|
string crosshairSecondary;
|
|
|
|
float fireChannelUpto;
|
|
};
|
|
|
|
boolean weapon_base::ShouldRunGuis() {
|
|
return myPlayer == sys.getLocalViewPlayer() && myPlayer != $null_entity;
|
|
}
|
|
|
|
void weapon_base::preinit() {
|
|
fireRate = getFloatKeyWithDefault( "fire_rate", 0.2f );
|
|
numProjectiles = getFloatKeyWithDefault( "num_projectiles", 1.f );
|
|
range = getFloatKeyWithDefault( "range", 8192 );
|
|
triggerDelay = getFloatKeyWithDefault( "trigger_delay", 0.f );
|
|
reloadAmmo = getFloatKeyWithDefault( "reload_ammo", 1.f );
|
|
numModes = getFloatKeyWithDefault( "num_modes", 1.f );
|
|
lowAmmoWarn = getFloatKeyWithDefault( "low_ammo", 3.f );
|
|
speedMod = getFloatKeyWithDefault( "speed_mod", 1.f );
|
|
fovZoom = getFloatKeyWithDefault( "fov_zoom", 60.f );
|
|
fovTime = getFloatKeyWithDefault( "fov_time", 0.25f );
|
|
fovSpeed = getFloatKeyWithDefault( "fov_speed", 0.5f );
|
|
fovSpread = getFloatKeyWithDefault( "fov_spread", 0.5f );
|
|
spreadModifier = getFloatKeyWithDefault( "spread_bonus", 0.8f );
|
|
overheatLength = getFloatKeyWithDefault( "overheat_length", 5 );
|
|
overheatPerShot = getFloatKeyWithDefault( "overheat_per_shot", 0.5 );
|
|
heatTimerHandle = sys.allocTargetTimer( getKeyWithDefault( "timer_heat", "heat_default" ) );
|
|
chargePerUse = getFloatKeyWithDefault( "charge_per_use", 10.f ) / 100.f;
|
|
showAllAmmo = getFloatKeyWithDefault( "show_all_ammo", 0 ) == 1;
|
|
showClip = getFloatKeyWithDefault( "hide_clip", 0 ) != 1;
|
|
hideAmmo = getFloatKeyWithDefault( "hide_ammo", 0 );
|
|
needsAmmoBox = getFloatKeyWithDefault( "needsAmmoBox", 1 );
|
|
showCharge = getFloatKeyWithDefault( "show_charge", 0 );
|
|
hideCrosshair = getFloatKeyWithDefault( "hide_crosshair", 1 ) != 0.f;
|
|
noEnergySegments = getFloatKeyWithDefault( "no_energy_segments", 0 ) != 0.f;
|
|
|
|
idleEffectJoint = getKeyWithDefault( "idle_effect_joint", "muzzle" );
|
|
|
|
crosshairPrimary = getKeyWithDefault( "crosshair", "small" );
|
|
crosshairSecondary = getKeyWithDefault( "crosshair_secondary", crosshairPrimary );
|
|
|
|
reFire = 0;
|
|
|
|
myPlayer = getOwner();
|
|
myPlayer.SetIronSightUp( false );
|
|
|
|
|
|
team_base team = myPlayer.getGameTeam();
|
|
|
|
float diff = 1.f - speedMod;
|
|
if ( diff > 0.f ) {
|
|
speedMod = speedMod + ( diff * team.GetWeaponSpeedBonus( myPlayer ) );
|
|
}
|
|
}
|
|
|
|
void weapon_base::init() {
|
|
vCheckProficiency();
|
|
|
|
show();
|
|
myPlayer.setSpeedModifier( speedMod );
|
|
UpdateCrosshair();
|
|
}
|
|
|
|
void weapon_base::StartIdleEffect() {
|
|
if ( !idleEffectOn ) {
|
|
playEffect( "fx_idle", idleEffectJoint, 1 );
|
|
idleEffectOn = true;
|
|
}
|
|
}
|
|
|
|
void weapon_base::StopIdleEffect() {
|
|
if ( idleEffectOn ) {
|
|
stopEffect( "fx_idle" );
|
|
idleEffectOn = false;
|
|
}
|
|
}
|
|
|
|
void weapon_base::UpdateCrosshair() {
|
|
entity proxy = myPlayer.getProxyEntity();
|
|
boolean allowInProxy = true;
|
|
if ( proxy != $null_entity ) {
|
|
allowInProxy = myPlayer.getProxyAllowWeapon();
|
|
}
|
|
|
|
if( ShouldRunGuis() && allowInProxy ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowAllAmmo", showAllAmmo );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowClip", showClip );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponHideAmmo", hideAmmo );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponNeedsAmmoBox", needsAmmoBox );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCustom", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCharge", showCharge );
|
|
if ( !noEnergySegments ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.energySegments", chargePerUse * 100 );
|
|
}
|
|
|
|
SetCrosshair();
|
|
}
|
|
}
|
|
|
|
void weapon_base::SetCrosshair() {
|
|
if ( myPlayer.IsSniperScopeUp() || ironSightsEnabled ) {
|
|
sys.setGUIString( GUI_GLOBALS_HANDLE, "gameHud.weaponCrosshair", crosshairSecondary );
|
|
} else {
|
|
sys.setGUIString( GUI_GLOBALS_HANDLE, "gameHud.weaponCrosshair", crosshairPrimary );
|
|
}
|
|
}
|
|
|
|
void weapon_base::UpdateCharge() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.energyAvailable", myPlayer.EnergyBar_CanRemove( chargePerUse ) );
|
|
}
|
|
}
|
|
|
|
void weapon_base::destroy() {
|
|
if ( myPlayer != $null_entity ) {
|
|
myPlayer.disableSprint( 0.f );
|
|
myPlayer.disableRun( 0.f );
|
|
myPlayer.setSpeedModifier( 1.f );
|
|
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowAllAmmo", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowClip", 1 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponHideAmmo", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCustom", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponNeedsAmmoBox", 0 );
|
|
|
|
sys.setGUIString( GUI_GLOBALS_HANDLE, "gameHud.weaponCrosshair", "small" );
|
|
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponReloadTime", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponLowAmmo", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.energyAvailable", 1 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCharge", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.energySegments", 1 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.cooling", 0.f );
|
|
}
|
|
}
|
|
|
|
stopSound( SND_WEAPON_IDLE );
|
|
stopSound( SND_WEAPON_RELOAD );
|
|
|
|
setFov( sys.getDefaultFov(), sys.getDefaultFov(), 0.f );
|
|
ShowSights();
|
|
|
|
RemoveLocalIronSightsEffects();
|
|
|
|
StopIdleEffect();
|
|
}
|
|
|
|
float weapon_base::GetFovSpread() {
|
|
if ( ironSightsEnabled ) {
|
|
return fovSpread;
|
|
}
|
|
return 1.f;
|
|
}
|
|
|
|
void weapon_base::UpdateSpreadModifiers() {
|
|
float spread = 1.f;
|
|
|
|
if ( DisableSpread() ) { // scoped rifles have sway instead of spread
|
|
spread = 0.f;
|
|
} else {
|
|
spread = spread * GetFovSpread();
|
|
|
|
if ( myPlayer != $null_entity ) {
|
|
team_base team = myPlayer.getGameTeam();
|
|
if ( team != $null ) {
|
|
if ( team.HasSpreadBonus( myPlayer ) ) {
|
|
spread = spread * spreadModifier;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
setSpreadModifier( spread );
|
|
}
|
|
|
|
void weapon_base::DisableIronSights() {
|
|
wantsIronSights = false;
|
|
CreateIronSightsThread();
|
|
}
|
|
|
|
void weapon_base::EnableIronSights() {
|
|
wantsIronSights = true;
|
|
CreateIronSightsThread();
|
|
}
|
|
|
|
void weapon_base::OnBecomeViewWeapon() {
|
|
if ( localIronSightsEffectsActive ) {
|
|
AddLocalIronSightsEffects();
|
|
}
|
|
UpdateCrosshair();
|
|
}
|
|
|
|
void weapon_base::OnFinishViewWeapon() {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponReloadTime", 0 );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.cooling", 0.f );
|
|
RemoveLocalIronSightsEffects();
|
|
}
|
|
|
|
void weapon_base::RemoveLocalIronSightsEffects() {
|
|
if ( !localIronSightsEffectsEnabled ) {
|
|
return;
|
|
}
|
|
|
|
localIronSightsEffectsEnabled = false;
|
|
|
|
ShowSights();
|
|
FreeScopeGUI();
|
|
}
|
|
|
|
void weapon_base::DisableIronSights_Private( boolean allowWait ) {
|
|
// just to make sure that anything calling this from elsewhere sets the state up correctly
|
|
wantsIronSights = false;
|
|
|
|
setDriftScale( 1.f );
|
|
setFov( fovZoom, sys.getDefaultFov(), fovTime * 0.46f );
|
|
if ( allowWait ) {
|
|
PlayZoomOutAnim();
|
|
waitUntil( animDone( ANIMCHANNEL_ALL, 4 ) );
|
|
}
|
|
|
|
localIronSightsEffectsActive = false;
|
|
RemoveLocalIronSightsEffects();
|
|
|
|
myPlayer.setSpeedModifier( speedMod );
|
|
|
|
ironSightsEnabled = false;
|
|
myPlayer.SetIronSightUp( ironSightsEnabled );
|
|
ironSightsTimeout = sys.getTime() + 0.5f;
|
|
|
|
setBlendFrames( ANIMCHANNEL_ALL, 4 );
|
|
PlayIdleAnim();
|
|
|
|
OnIronSightsDisabled();
|
|
|
|
UpdateSpreadModifiers();
|
|
}
|
|
|
|
void weapon_base::AddLocalIronSightsEffects() {
|
|
if ( localIronSightsEffectsEnabled ) {
|
|
return;
|
|
}
|
|
|
|
if ( myPlayer == $null_entity ) {
|
|
return;
|
|
}
|
|
|
|
if ( myPlayer == sys.getLocalViewPlayer() ) {
|
|
localIronSightsEffectsEnabled = true;
|
|
|
|
HideSights();
|
|
LoadScopeGUI();
|
|
}
|
|
}
|
|
|
|
void weapon_base::EnableIronSights_Private( boolean allowWait ) {
|
|
// just to make sure that anything calling this from elsewhere sets the state up correctly
|
|
wantsIronSights = true;
|
|
|
|
setDriftScale( 0.f );
|
|
if ( allowWait ) {
|
|
PlayZoomInAnim();
|
|
sys.waitFrame();
|
|
setFovStart( sys.getDefaultFov(), fovZoom, fovTime * 0.0f, fovTime * 0.6f );
|
|
waitUntil( animDone( ANIMCHANNEL_ALL, 4 ) );
|
|
} else {
|
|
setFovStart( sys.getDefaultFov(), fovZoom, fovTime * 0.0f, fovTime * 0.6f );
|
|
}
|
|
|
|
localIronSightsEffectsActive = true;
|
|
AddLocalIronSightsEffects();
|
|
|
|
myPlayer.setSpeedModifier( speedMod * fovSpeed );
|
|
|
|
ironSightsEnabled = true;
|
|
myPlayer.SetIronSightUp( ironSightsEnabled );
|
|
ironSightsTimeout = sys.getTime() + 0.5f;
|
|
|
|
setBlendFrames( ANIMCHANNEL_ALL, 4 );
|
|
PlayIdleAnim();
|
|
|
|
OnIronSightsEnabled();
|
|
|
|
UpdateSpreadModifiers();
|
|
}
|
|
|
|
void weapon_base::CheckIronSights() {
|
|
if ( sys.getTime() > ironSightsTimeout ) {
|
|
if ( myPlayer.IsIronSightUp() != ironSightsEnabled ) {
|
|
// the timeout period has elapsed but the server doesn't agree about the ironsights
|
|
// so need to force ourself into the other state
|
|
// this seems to be a very rare thing to happen.
|
|
if ( !ironSightsEnabled ) {
|
|
EnableIronSights_Private( false );
|
|
} else {
|
|
DisableIronSights_Private( false );
|
|
}
|
|
|
|
setBlendFrames( ANIMCHANNEL_ALL, 4 );
|
|
PlayIdleAnim();
|
|
}
|
|
}
|
|
|
|
if ( WEAPON_ALTFIRE ) {
|
|
if( !altFireDown ) {
|
|
ToggleIronSights();
|
|
waitUntil( !ironSightsThreadActive );
|
|
altFireDown = true;
|
|
}
|
|
} else {
|
|
altFireDown = false;
|
|
}
|
|
}
|
|
|
|
void weapon_base::ToggleIronSights() {
|
|
if ( wantsIronSights ) {
|
|
wantsIronSights = false;
|
|
} else {
|
|
wantsIronSights = true;
|
|
}
|
|
|
|
CreateIronSightsThread();
|
|
}
|
|
|
|
void weapon_base::CreateIronSightsThread() {
|
|
if ( ironSightsThreadActive ) {
|
|
return;
|
|
}
|
|
|
|
ironSightsThreadActive = true;
|
|
thread IronSightsThread();
|
|
}
|
|
|
|
void weapon_base::StopIronSightsThread() {
|
|
sys.killThread( "IronSightsThread_" + getName() );
|
|
}
|
|
|
|
void weapon_base::IronSightsThread() {
|
|
while ( true ) {
|
|
if ( ironSightsEnabled == wantsIronSights ) {
|
|
break;
|
|
}
|
|
|
|
if ( wantsIronSights ) {
|
|
EnableIronSights_Private( true );
|
|
} else {
|
|
DisableIronSights_Private( true );
|
|
}
|
|
|
|
UpdateCrosshair();
|
|
sys.waitFrame();
|
|
}
|
|
|
|
ironSightsThreadActive = false;
|
|
|
|
StopIronSightsThread();
|
|
}
|
|
|
|
void weapon_base::HideSights() {
|
|
if ( !sightsHidden ) {
|
|
sightsHidden = true;
|
|
if ( !myPlayer.isGunHidden() ) {
|
|
HideCrosshair();
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::ShowSights() {
|
|
if ( sightsHidden ) {
|
|
sightsHidden = false;
|
|
ShowCrosshair();
|
|
}
|
|
}
|
|
|
|
void weapon_base::ShowCrosshair() {
|
|
if ( hideCrosshair ) {
|
|
if ( ShouldRunGuis() ) {
|
|
float count = sys.getGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.hideCrosshairCounter" );
|
|
count = count - 1;
|
|
if ( count < 0 ) {
|
|
count = 0;
|
|
}
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.hideCrosshairCounter", count );
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::HideCrosshair() {
|
|
if ( hideCrosshair ) {
|
|
if ( ShouldRunGuis() ) {
|
|
float count = sys.getGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.hideCrosshairCounter" );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.hideCrosshairCounter", count + 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::UseAmmo( float modIndex ) {
|
|
if( ammoAvailable( modIndex ) == ( lowAmmoWarn * 2 ) ) {
|
|
if ( myPlayer != $null_entity && myPlayer == sys.getLocalPlayer() ) {
|
|
if ( !myPlayer.isToolTipPlaying() ) {
|
|
team_base team = myPlayer.getGameTeam();
|
|
if ( myPlayer.getPlayerClass() == g_playerClassFieldOps ) {
|
|
myPlayer.sendToolTip( team.lowAmmoSelfToolTip );
|
|
} else {
|
|
myPlayer.sendToolTip( team.lowAmmoToolTip );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( sys.isClient() ) {
|
|
return;
|
|
}
|
|
|
|
float amount = ammoRequired( modIndex );
|
|
useAmmo( ammoType( modIndex ), amount );
|
|
addToClip( modIndex, -amount );
|
|
}
|
|
|
|
void weapon_base::UseAmmo_Stroyent( float modIndex ) {
|
|
if( ammoAvailable( modIndex ) == ( lowAmmoWarn * 2 ) ) {
|
|
if ( myPlayer != $null_entity && myPlayer == sys.getLocalPlayer() ) {
|
|
if ( !myPlayer.isSinglePlayerToolTipPlaying() ) {
|
|
myPlayer.cancelToolTips();
|
|
team_base team = myPlayer.getGameTeam();
|
|
if ( myPlayer.getPlayerClass() == g_playerClassTechnician ) {
|
|
myPlayer.sendToolTip( team.lowAmmoSelfToolTip );
|
|
} else {
|
|
myPlayer.sendToolTip( team.lowAmmoToolTip );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( sys.isClient() ) {
|
|
return;
|
|
}
|
|
|
|
float amount = ammoRequired( modIndex );
|
|
useAmmo( ammoType( modIndex ), amount );
|
|
}
|
|
|
|
void weapon_base::LaunchProjectile( float modIndex, float projectileIndex ) {
|
|
launchProjectiles( numProjectiles, projectileIndex, getCurrentSpread(), 0, 1, 1 );
|
|
|
|
UseAmmo( modIndex );
|
|
|
|
increaseSpread();
|
|
}
|
|
|
|
void weapon_base::LaunchProjectile_Stroyent( float modIndex, float projectileIndex ) {
|
|
launchProjectiles( numProjectiles, projectileIndex, getCurrentSpread(), 0, 1, 1 );
|
|
|
|
UseAmmo_Stroyent( modIndex );
|
|
AddHeat();
|
|
|
|
increaseSpread();
|
|
}
|
|
|
|
void weapon_base::AmmoCheckClip( float modIndex ) {
|
|
if( ammoInClip( modIndex ) == lowAmmoWarn ) {
|
|
sys.waitFrame();
|
|
startSound( "snd_lowAmmo", SND_WEAPON_SIG );
|
|
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponLowAmmo", 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::AmmoCheck( float modIndex ) {
|
|
if( ammoAvailable( modIndex ) == lowAmmoWarn ) {
|
|
sys.waitFrame();
|
|
startSound( "snd_lowAmmo", SND_WEAPON_SIG );
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponLowAmmo", 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::PlayFireSound() {
|
|
// float diversePitch = 0.75f + sys.random( 0.5f );
|
|
|
|
fireChannelUpto = fireChannelUpto + 1;
|
|
if ( fireChannelUpto > SND_WEAPON_FIRE_NUM - 1 ) {
|
|
fireChannelUpto = 0;
|
|
}
|
|
|
|
startSound( "snd_fire_local", SND_WEAPON_FIRE_LOCAL_START + fireChannelUpto );
|
|
// setChannelPitchShift( SND_WEAPON_FIRE_LOCAL, diversePitch );
|
|
startSound( "snd_fire", SND_WEAPON_FIRE );
|
|
startSound( "snd_fire_far", SND_WEAPON_FIRE_FAR );
|
|
}
|
|
|
|
void weapon_base::StopFireSound() {
|
|
startSound( "snd_fire_local_trail", SND_WEAPON_FIRE_LOCAL );
|
|
startSound( "snd_fire_trail", SND_WEAPON_FIRE );
|
|
startSound( "snd_fire_far_trail", SND_WEAPON_FIRE_FAR );
|
|
}
|
|
|
|
void weapon_base::DestroySound() {
|
|
}
|
|
|
|
void weapon_base::Base_OnProxyEnter() {
|
|
vCancelFire();
|
|
}
|
|
|
|
void weapon_base::OnProxyEnter() {
|
|
Base_OnProxyEnter();
|
|
}
|
|
|
|
void weapon_base::Base_OnProxyExit() {
|
|
UpdateCrosshair();
|
|
}
|
|
|
|
void weapon_base::OnProxyExit() {
|
|
Base_OnProxyExit();
|
|
}
|
|
|
|
void weapon_base::AddHeat() {
|
|
float heatValue = sys.getTargetTimerValue( heatTimerHandle, myPlayer );
|
|
|
|
if ( heatValue < sys.getTime() ) {
|
|
heatValue = sys.getTime();
|
|
}
|
|
|
|
heatValue = heatValue + overheatPerShot;
|
|
|
|
sys.setTargetTimerValue( heatTimerHandle, myPlayer, heatValue );
|
|
}
|
|
|
|
boolean weapon_base::IsOverheated() {
|
|
if ( myPlayer == $null_entity ) {
|
|
return false;
|
|
}
|
|
|
|
float heatValue = sys.getTargetTimerValue( heatTimerHandle, myPlayer );
|
|
if ( ( heatValue - sys.getTime() ) >= overheatLength ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void weapon_base::KillUpdateHeat() {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.showHeat", 0.f );
|
|
sys.killThread( "UpdateHeat_" + getName() );
|
|
}
|
|
|
|
void weapon_base::CreateUpdateHeat() {
|
|
KillUpdateHeat();
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.showHeat", 1.f );
|
|
thread UpdateHeat();
|
|
}
|
|
|
|
void weapon_base::HideUseCount() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.showUseCount", 0.f );
|
|
}
|
|
}
|
|
|
|
void weapon_base::ShowUseCount() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.showUseCount", 1.f );
|
|
}
|
|
}
|
|
|
|
void weapon_base::UpdateHeat() {
|
|
float heatValue;
|
|
float fraction;
|
|
|
|
while ( true ) {
|
|
sys.waitFrame();
|
|
|
|
heatValue = sys.getTargetTimerValue( heatTimerHandle, myPlayer ) - sys.getTime();
|
|
if ( heatValue < 0 ) {
|
|
heatValue = 0;
|
|
} else if ( heatValue > overheatLength ) {
|
|
heatValue = overheatLength;
|
|
}
|
|
|
|
fraction = 1 - ( heatValue / overheatLength );
|
|
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.heat", fraction );
|
|
}
|
|
}
|
|
|
|
void weapon_base::StartCooling() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.cooling", 1.f );
|
|
}
|
|
}
|
|
|
|
void weapon_base::FinishCooling() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "weapons.cooling", 0.f );
|
|
}
|
|
}
|
|
|
|
void weapon_base::PlayFireEffect() {
|
|
if ( sys.getLocalViewPlayer() != myPlayer || pm_thirdperson.getBoolValue() ) {
|
|
entity worldModel = getWorldModel( 0 ); // FIXME
|
|
worldModel.playEffect( "fx_muzzle_flash_world", "muzzle", 0.0f );
|
|
} else {
|
|
if ( AllowLocalMuzzleFlash() ) {
|
|
playEffect( "fx_muzzle_flash", "muzzle", 0.f );
|
|
} else {
|
|
playEffect( "fx_muzzle_flash_novisuals", "muzzle", 0.f );
|
|
}
|
|
}
|
|
}
|
|
|
|
void weapon_base::Base_BeginReload() {
|
|
if ( ShouldRunGuis() ) {
|
|
float reloadTime = getAnimLength( "reload" );
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponReloadTime", reloadTime );
|
|
}
|
|
}
|
|
|
|
void weapon_base::Base_EndReload() {
|
|
if ( ShouldRunGuis() ) {
|
|
sys.setGUIFloat( GUI_GLOBALS_HANDLE, "gameHud.weaponReloadTime", 0 );
|
|
}
|
|
}
|
|
|
|
void weapon_base::Base_Raise() {
|
|
UpdateCrosshair();
|
|
if ( myPlayer.AI_SPRINT ) {
|
|
DoRaise( "Sprint", 4 );
|
|
} else {
|
|
if ( NeedsReload() && CanReload() ) {
|
|
DoRaise( "Reload", 4 );
|
|
} else {
|
|
DoRaise( "Idle", 4 );
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean weapon_base::HasNoAmmo() {
|
|
return ammoAvailable( 0 ) == 0;
|
|
}
|
|
|
|
void weapon_base::DoRaise( string newState, float blend ) {
|
|
if ( HasNoAmmo() ) {
|
|
weaponHolstered();
|
|
nextWeapon();
|
|
return;
|
|
}
|
|
weaponRising();
|
|
|
|
playAnim( ANIMCHANNEL_ALL, "raise" );
|
|
while ( !animDone( ANIMCHANNEL_ALL, 4 ) ) {
|
|
sys.waitFrame();
|
|
if ( WEAPON_LOWERWEAPON ) {
|
|
weaponState( "Lower", 4 );
|
|
}
|
|
}
|
|
|
|
if ( getKey( "snd_idle" ) != "" ) {
|
|
startSound( "snd_idle", SND_WEAPON_IDLE );
|
|
}
|
|
|
|
weaponState( newState, blend );
|
|
}
|
|
|
|
void weapon_base::Base_Lower() {
|
|
DisableIronSights();
|
|
waitUntil( !ironSightsThreadActive );
|
|
|
|
stopSound( SND_WEAPON_IDLE );
|
|
StopIdleEffect();
|
|
|
|
weaponLowering();
|
|
playAnim( ANIMCHANNEL_ALL, "putaway" );
|
|
waitUntil( animDone( ANIMCHANNEL_ALL, 4 ) );
|
|
weaponHolstered();
|
|
waitUntil( WEAPON_RAISEWEAPON );
|
|
weaponState( "Raise", 0 );
|
|
}
|
|
|
|
void weapon_base::LeaveSprint( string newState, float blend ) {
|
|
if ( WEAPON_ATTACK ) {
|
|
mainFireDown = false;
|
|
}
|
|
|
|
PlayLeaveSprintAnim( newState, blend );
|
|
|
|
weaponState( newState, blend );
|
|
}
|
|
|
|
void weapon_base::Sprint() {
|
|
DisableIronSights();
|
|
waitUntil( !ironSightsThreadActive );
|
|
|
|
weaponReady();
|
|
|
|
PlayStartSprintAnim();
|
|
|
|
StartIdleEffect();
|
|
|
|
while ( true ) {
|
|
if ( WEAPON_LOWERWEAPON ) {
|
|
LeaveSprint( "Lower", 4 );
|
|
}
|
|
|
|
if ( !myPlayer.AI_SPRINT ) {
|
|
if ( NeedsReload() && CanReload() ) {
|
|
LeaveSprint( "Reload", 4 );
|
|
} else {
|
|
LeaveSprint( "Idle", 4 );
|
|
}
|
|
}
|
|
|
|
if ( WEAPON_ATTACK ) {
|
|
LeaveSprint( "Idle", 4 );
|
|
}
|
|
|
|
UpdateCharge();
|
|
|
|
sys.waitFrame();
|
|
}
|
|
}
|
|
|
|
void weapon_base::OnNetworkReload() {
|
|
string currentState = getWeaponState();
|
|
|
|
if ( currentState == "Idle" || currentState == "Fire" ) {
|
|
weaponState( "Reload", 4 );
|
|
}
|
|
}
|
|
|
|
void weapon_base::vCheckProficiency() {
|
|
WeaponBase_CheckProficiency();
|
|
}
|
|
|
|
void weapon_base::WeaponBase_CheckProficiency() {
|
|
UpdateSpreadModifiers();
|
|
}
|
|
|
|
boolean weapon_base::CanRemove( float amount ) {
|
|
return myPlayer.EnergyBar_CanRemove( amount );
|
|
}
|
|
|
|
void weapon_base::Remove( float amount ) {
|
|
myPlayer.EnergyBar_Remove( amount );
|
|
}
|
|
|
|
boolean weapon_base::AllowLocalMuzzleFlash() {
|
|
if ( myPlayer.IsSniperScopeUp() ) {
|
|
return false;
|
|
}
|
|
|
|
// Gordon: make it a property of the team, not a team check
|
|
if ( myPlayer.getGameTeam() == stroggTeam && ironSightsEnabled ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void weapon_base::PlayIdleAnim() {
|
|
if ( ironSightsEnabled ) {
|
|
playCycle( ANIMCHANNEL_ALL, "idle_zoom" );
|
|
} else {
|
|
playCycle( ANIMCHANNEL_ALL, "idle" );
|
|
}
|
|
}
|
|
|
|
void weapon_base::PlayZoomInAnim() {
|
|
playAnim( ANIMCHANNEL_ALL, "zoomin" );
|
|
}
|
|
|
|
void weapon_base::PlayZoomOutAnim() {
|
|
playAnim( ANIMCHANNEL_ALL, "zoomout" );
|
|
}
|
|
|
|
void weapon_base::PlayStartSprintAnim() {
|
|
if ( hasWeaponAnim( "start_sprint" ) ) {
|
|
playAnim( ANIMCHANNEL_ALL, "start_sprint" );
|
|
waitUntil( animDone( ANIMCHANNEL_ALL, 4 ) );
|
|
}
|
|
}
|
|
|
|
void weapon_base::PlayLeaveSprintAnim( string newState, float blend ) {
|
|
if ( hasWeaponAnim( "leave_sprint" ) ) {
|
|
playAnim( ANIMCHANNEL_ALL, "leave_sprint" );
|
|
waitUntil( animDone( ANIMCHANNEL_ALL, 4 ) );
|
|
}
|
|
}
|