d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
149 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 61cd8d0afc
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '61cd8d0afc'
${ noResults }
source-engine/game/shared/hl1/hl1mp_weapon_gauss.cpp

719 lines
17 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Gauss
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "npcevent.h"
#include "hl1mp_basecombatweapon_shared.h"
//#include "basecombatcharacter.h"
//#include "AI_BaseNPC.h"
#include "takedamageinfo.h"
#ifdef CLIENT_DLL
#include "hl1/hl1_c_player.h"
#else
#include "hl1_player.h"
#endif
#include "gamerules.h"
#include "in_buttons.h"
#ifdef CLIENT_DLL
#else
#include "soundent.h"
#include "game.h"
#endif
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "soundenvelope.h"
//#include "hl1_player.h"
#include "shake.h"
#include "effect_dispatch_data.h"
#ifdef CLIENT_DLL
#include "c_te_effect_dispatch.h"
#else
#include "te_effect_dispatch.h"
#endif
#include "SoundEmitterSystem/isoundemittersystembase.h"
#define GAUSS_GLOW_SPRITE "sprites/hotglow.vmt"
#define GAUSS_BEAM_SPRITE "sprites/smoke.vmt"
extern ConVar sk_plr_dmg_gauss;
#ifdef CLIENT_DLL
#define CWeaponGauss C_WeaponGauss
#endif
//-----------------------------------------------------------------------------
// CWeaponGauss
//-----------------------------------------------------------------------------
class CWeaponGauss : public CBaseHL1MPCombatWeapon
{
DECLARE_CLASS( CWeaponGauss, CBaseHL1MPCombatWeapon );
public:
DECLARE_NETWORKCLASS();
DECLARE_PREDICTABLE();
CWeaponGauss( void );
void Precache( void );
void PrimaryAttack( void );
void SecondaryAttack( void );
void WeaponIdle( void );
void AddViewKick( void );
bool Deploy( void );
bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
// DECLARE_SERVERCLASS();
DECLARE_DATADESC();
private:
void StopSpinSound( void );
float GetFullChargeTime( void );
void StartFire( void );
void Fire( Vector vecOrigSrc, Vector vecDir, float flDamage );
private:
// int m_nAttackState;
// bool m_bPrimaryFire;
CNetworkVar( int, m_nAttackState);
CNetworkVar( bool, m_bPrimaryFire);
CSoundPatch *m_sndCharge;
};
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGauss, DT_WeaponGauss );
BEGIN_NETWORK_TABLE( CWeaponGauss, DT_WeaponGauss )
#ifdef CLIENT_DLL
RecvPropInt( RECVINFO( m_nAttackState ) ),
RecvPropBool( RECVINFO( m_bPrimaryFire ) ),
#else
SendPropInt( SENDINFO( m_nAttackState ) ),
SendPropBool( SENDINFO( m_bPrimaryFire ) ),
#endif
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CWeaponGauss )
#ifdef CLIENT_DLL
DEFINE_PRED_FIELD( m_nAttackState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bPrimaryFire, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
#endif
END_PREDICTION_DATA()
LINK_ENTITY_TO_CLASS( weapon_gauss, CWeaponGauss );
PRECACHE_WEAPON_REGISTER( weapon_gauss );
//IMPLEMENT_SERVERCLASS_ST( CWeaponGauss, DT_WeaponGauss )
//END_SEND_TABLE()
BEGIN_DATADESC( CWeaponGauss )
DEFINE_FIELD( m_nAttackState, FIELD_INTEGER ),
DEFINE_FIELD( m_bPrimaryFire, FIELD_BOOLEAN ),
DEFINE_SOUNDPATCH( m_sndCharge ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CWeaponGauss::CWeaponGauss( void )
{
m_bReloadsSingly = false;
m_bFiresUnderwater = false;
m_bPrimaryFire = false;
m_nAttackState = 0;
m_sndCharge = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponGauss::Precache( void )
{
PrecacheModel( GAUSS_GLOW_SPRITE );
PrecacheModel( GAUSS_BEAM_SPRITE );
PrecacheScriptSound( "Weapon_Gauss.Zap1" );
PrecacheScriptSound( "Weapon_Gauss.Zap2" );
PrecacheScriptSound( "Weapon_Gauss.Fire" );
PrecacheScriptSound( "Weapon_Gauss.StaticDischarge" );
PrecacheScriptSound( "Weapon_Gauss.Spin" );
BaseClass::Precache();
}
float CWeaponGauss::GetFullChargeTime( void )
{
if ( g_pGameRules->IsMultiplayer() )
{
return 1.5;
}
else
{
return 4;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponGauss::PrimaryAttack( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
{
return;
}
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) < 2 )
{
WeaponSound( EMPTY );
pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
return;
}
//FIXME pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_FIRE_VOLUME;
m_bPrimaryFire = true;
pPlayer->RemoveAmmo( 2, m_iPrimaryAmmoType );
StartFire();
m_nAttackState = 0;
SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
pPlayer->SetNextAttack( gpGlobals->curtime + 0.2 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponGauss::SecondaryAttack( void )
{
CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
if ( !pPlayer )
{
return;
}
// don't fire underwater
if ( pPlayer->GetWaterLevel() == 3 )
{
if ( m_nAttackState != 0 )
{
EmitSound( "Weapon_Gauss.Zap1" );
SendWeaponAnim( ACT_VM_IDLE );
m_nAttackState = 0;
}
else
{
WeaponSound( EMPTY );
}
m_flNextSecondaryAttack = m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
return;
}
if ( m_nAttackState == 0 )
{
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
{
WeaponSound( EMPTY );
pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
return;
}
m_bPrimaryFire = false;
pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType ); // take one ammo just to start the spin
pPlayer->m_flNextAmmoBurn = gpGlobals->curtime;
// spin up
//FIXME pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
SendWeaponAnim( ACT_GAUSS_SPINUP );
m_nAttackState = 1;
SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
pPlayer->m_flStartCharge = gpGlobals->curtime;
pPlayer->m_flAmmoStartCharge = gpGlobals->curtime + GetFullChargeTime();
//Start looping sound
if ( m_sndCharge == NULL )
{
CPASAttenuationFilter filter( this );
m_sndCharge = (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_WEAPON, "Weapon_Gauss.Spin", ATTN_NORM );
}
if ( m_sndCharge != NULL )
{
(CSoundEnvelopeController::GetController()).Play( m_sndCharge, 1.0f, 110 );
}
}
else if (m_nAttackState == 1)
{
if ( HasWeaponIdleTimeElapsed() )
{
SendWeaponAnim( ACT_GAUSS_SPINCYCLE );
m_nAttackState = 2;
}
}
else
{
// during the charging process, eat one bit of ammo every once in a while
if ( gpGlobals->curtime >= pPlayer->m_flNextAmmoBurn && pPlayer->m_flNextAmmoBurn != 1000 )
{
pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
if ( g_pGameRules->IsMultiplayer() )
{
pPlayer->m_flNextAmmoBurn = gpGlobals->curtime + 0.1;
}
else
{
pPlayer->m_flNextAmmoBurn = gpGlobals->curtime + 0.3;
}
}
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
{
// out of ammo! force the gun to fire
StartFire();
m_nAttackState = 0;
SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
pPlayer->SetNextAttack( gpGlobals->curtime + 1 );
return;
}
if ( gpGlobals->curtime >= pPlayer->m_flAmmoStartCharge )
{
// don't eat any more ammo after gun is fully charged.
pPlayer->m_flNextAmmoBurn = 1000;
}
int pitch = ( gpGlobals->curtime - pPlayer->m_flStartCharge ) * ( 150 / GetFullChargeTime() ) + 100;
if ( pitch > 250 )
pitch = 250;
// ALERT( at_console, "%d %d %d\n", m_nAttackState, m_iSoundState, pitch );
// if ( m_iSoundState == 0 )
// ALERT( at_console, "sound state %d\n", m_iSoundState );
if ( m_sndCharge != NULL )
{
(CSoundEnvelopeController::GetController()).SoundChangePitch( m_sndCharge, pitch, 0 );
}
//FIXME m_pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
// m_flTimeWeaponIdle = gpGlobals->curtime + 0.1;
if ( pPlayer->m_flStartCharge < gpGlobals->curtime - 10 )
{
// Player charged up too long. Zap him.
EmitSound( "Weapon_Gauss.Zap1" );
EmitSound( "Weapon_Gauss.Zap2" );
m_nAttackState = 0;
SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
pPlayer->SetNextAttack( gpGlobals->curtime + 1.0 );
#if !defined(CLIENT_DLL )
// Add DMG_CRUSH because we don't want any physics force
pPlayer->TakeDamage( CTakeDamageInfo( this, this, 50, DMG_SHOCK | DMG_CRUSH ) );
color32 gaussDamage = {255,128,0,128};
UTIL_ScreenFade( pPlayer, gaussDamage, 2, 0.5, FFADE_IN );
#endif
SendWeaponAnim( ACT_VM_IDLE );
StopSpinSound();
// Player may have been killed and this weapon dropped, don't execute any more code after this!
return;
}
}
}
//=========================================================
// StartFire- since all of this code has to run and then
// call Fire(), it was easier at this point to rip it out
// of weaponidle() and make its own function then to try to
// merge this into Fire(), which has some identical variable names
//=========================================================
void CWeaponGauss::StartFire( void )
{
float flDamage;
CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
if ( !pPlayer )
{
return;
}
Vector vecAiming = pPlayer->GetAutoaimVector( 0 );
Vector vecSrc = pPlayer->Weapon_ShootPosition( );
if ( gpGlobals->curtime - pPlayer->m_flStartCharge > GetFullChargeTime() )
{
flDamage = 200;
}
else
{
flDamage = 200 * (( gpGlobals->curtime - pPlayer->m_flStartCharge) / GetFullChargeTime() );
}
if ( m_bPrimaryFire )
{
flDamage = sk_plr_dmg_gauss.GetFloat() * g_pGameRules->GetDamageMultiplier();
}
//ALERT ( at_console, "Time:%f Damage:%f\n", gpGlobals->curtime - m_pPlayer->m_flStartCharge, flDamage );
Vector vecNewVel = pPlayer->GetAbsVelocity();
float flZVel = vecNewVel.z;
if ( !m_bPrimaryFire )
{
vecNewVel = vecNewVel - vecAiming * flDamage * 5;
pPlayer->SetAbsVelocity( vecNewVel );
}
if ( !g_pGameRules->IsMultiplayer() )
{
// in deathmatch, gauss can pop you up into the air. Not in single play.
vecNewVel.z = flZVel;
pPlayer->SetAbsVelocity( vecNewVel );
}
// player "shoot" animation
pPlayer->SetAnimation( PLAYER_ATTACK1 );
// time until aftershock 'static discharge' sound
pPlayer->m_flPlayAftershock = gpGlobals->curtime + random->RandomFloat( 0.3, 0.8 );
Fire( vecSrc, vecAiming, flDamage );
}
void CWeaponGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
{
CBaseEntity *pIgnore;
Vector vecSrc = vecOrigSrc;
Vector vecDest = vecSrc + vecDir * MAX_TRACE_LENGTH;
bool fFirstBeam = true;
bool fHasPunched = false;
float flMaxFrac = 1.0;
int nMaxHits = 10;
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( !pPlayer )
{
return;
}
//FIXME pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_FIRE_VOLUME;
StopSpinSound();
pIgnore = pPlayer;
// ALERT( at_console, "%f %f\n", tr.flFraction, flMaxFrac );
while ( flDamage > 10 && nMaxHits > 0 )
{
trace_t tr;
nMaxHits--;
// ALERT( at_console, "." );
UTIL_TraceLine( vecSrc, vecDest, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &tr );
if ( tr.allsolid )
break;
CBaseEntity *pEntity = tr.m_pEnt;
if (pEntity == NULL)
break;
CBroadcastRecipientFilter filter;
CEffectData data6;
if ( fFirstBeam )
{
pPlayer->DoMuzzleFlash();
fFirstBeam = false;
data6.m_vOrigin = tr.endpos;
// data6.m_nEntIndex = pPlayer->GetViewModel()->entindex();
#ifdef CLIENT_DLL
data6.m_hEntity = pPlayer;
#else
data6.m_nEntIndex = pPlayer->entindex();
#endif
data6.m_fFlags = m_bPrimaryFire;
te->DispatchEffect( filter, 0.0, data6.m_vOrigin, "HL1GaussBeam", data6 );
}
else
{
data6.m_vOrigin = tr.endpos;
data6.m_vStart = vecSrc;
data6.m_fFlags = m_bPrimaryFire;
te->DispatchEffect( filter, 0.0, data6.m_vOrigin, "HL1GaussBeamReflect", data6 );
}
bool fShouldDamageEntity = ( pEntity->m_takedamage != DAMAGE_NO );
if ( fShouldDamageEntity )
{
ClearMultiDamage();
CTakeDamageInfo info( this, pPlayer, flDamage, DMG_ENERGYBEAM );
CalculateMeleeDamageForce( &info, vecDir, tr.endpos );
pEntity->DispatchTraceAttack( info, vecDir, &tr );
ApplyMultiDamage();
}
if ( pEntity->IsBSPModel() && !fShouldDamageEntity )
{
float n;
pIgnore = NULL;
n = -DotProduct( tr.plane.normal, vecDir );
if ( n < 0.5 ) // 60 degrees
{
// ALERT( at_console, "reflect %f\n", n );
// reflect
Vector vecReflect;
vecReflect = 2.0 * tr.plane.normal * n + vecDir;
flMaxFrac = flMaxFrac - tr.fraction;
vecDir = vecReflect;
vecSrc = tr.endpos;// + vecDir * 8;
vecDest = vecSrc + vecDir * MAX_TRACE_LENGTH;
#if !defined(CLIENT_DLL)
// explode a bit
RadiusDamage( CTakeDamageInfo( this, pPlayer, flDamage * n, DMG_BLAST ), tr.endpos, flDamage * n * 2.5, CLASS_NONE, NULL );
#endif
CEffectData data1;
data1.m_vOrigin = tr.endpos;
data1.m_vNormal = tr.plane.normal;
data1.m_flMagnitude = flDamage * n;
DispatchEffect( "HL1GaussReflect", data1 );
// lose energy
if (n == 0)
n = 0.1;
flDamage = flDamage * (1 - n);
}
else
{
// tunnel
UTIL_ImpactTrace( &tr, DMG_ENERGYBEAM );
CEffectData data4;
data4.m_vOrigin = tr.endpos;
data4.m_flMagnitude = flDamage;
DispatchEffect( "HL1GaussWallImpact1", data4 );
// limit it to one hole punch
if ( fHasPunched )
break;
fHasPunched = true;
// try punching through wall if secondary attack (primary is incapable of breaking through)
if ( !m_bPrimaryFire )
{
trace_t punch_tr;
UTIL_TraceLine( tr.endpos + vecDir * 8, vecDest, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &punch_tr);
if ( !punch_tr.allsolid )
{
trace_t exit_tr;
// trace backwards to find exit point
UTIL_TraceLine( punch_tr.endpos, tr.endpos, MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &exit_tr);
float n = (exit_tr.endpos - tr.endpos).Length( );
if ( n < flDamage )
{
if (n == 0)
n = 1;
flDamage -= n;
CEffectData data2;
data2.m_vOrigin = tr.endpos;
data2.m_vNormal = vecDir;
DispatchEffect( "HL1GaussWallPunchEnter", data2 );
UTIL_ImpactTrace( &exit_tr, DMG_ENERGYBEAM );
CEffectData data3;
data3.m_vOrigin = exit_tr.endpos;
data3.m_vNormal = vecDir;
data3.m_flMagnitude = flDamage;
DispatchEffect( "HL1GaussWallPunchExit", data3 );
// ALERT( at_console, "punch %f\n", n );
// exit blast damage
float flDamageRadius;
if ( g_pGameRules->IsMultiplayer() )
{
flDamageRadius = flDamage * 1.75; // Old code == 2.5
}
else
{
flDamageRadius = flDamage * 2.5;
}
#if !defined( CLIENT_DLL)
RadiusDamage( CTakeDamageInfo( this, pPlayer, flDamage, DMG_BLAST ), exit_tr.endpos + vecDir * 8, flDamageRadius, CLASS_NONE, NULL );
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 1024, 3.0 );
#endif
vecSrc = exit_tr.endpos + vecDir;
}
}
else
{
//ALERT( at_console, "blocked %f\n", n );
flDamage = 0;
}
}
else
{
//ALERT( at_console, "blocked solid\n" );
if ( m_bPrimaryFire )
{
// slug doesn't punch through ever with primary
// fire, so leave a little glowy bit and make some balls
CEffectData data5;
data5.m_vOrigin = tr.endpos;
data5.m_vNormal = tr.plane.normal;
DispatchEffect( "HL1GaussWallImpact2", data5 );
#if !defined( CLIENT_DLL)
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 600, 0.5 );
#endif
}
flDamage = 0;
}
}
}
else
{
vecSrc = tr.endpos + vecDir;
pIgnore = pEntity;
}
}
pPlayer->ViewPunch( QAngle( -2, 0, 0 ) );
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
CPASAttenuationFilter filter( this );
CSoundParameters params;
if ( GetParametersForSound( "Weapon_Gauss.Fire", params, NULL ) )
{
EmitSound_t ep( params );
ep.m_flVolume = 0.5 + flDamage * (1.0 / 400.0);
EmitSound( filter, entindex(), ep );
}
}
void CWeaponGauss::WeaponIdle( void )
{
CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
if ( !pPlayer )
{
return;
}
// play aftershock static discharge
if ( pPlayer->m_flPlayAftershock && pPlayer->m_flPlayAftershock < gpGlobals->curtime )
{
EmitSound( "Weapon_Gauss.StaticDischarge" );
pPlayer->m_flPlayAftershock = 0.0;
}
if ( !HasWeaponIdleTimeElapsed() )
return;
if ( m_nAttackState != 0 )
{
StartFire();
m_nAttackState = 0;
SetWeaponIdleTime( gpGlobals->curtime + 2.0 );
}
else
{
float flRand = random->RandomFloat( 0, 1 );
if ( flRand <= 0.75 )
{
SendWeaponAnim( ACT_VM_IDLE );
SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );
}
else
{
SendWeaponAnim( ACT_VM_FIDGET );
SetWeaponIdleTime( gpGlobals->curtime + 3 );
}
}
}
/*
==================================================
AddViewKick
==================================================
*/
void CWeaponGauss::AddViewKick( void )
{
}
bool CWeaponGauss::Deploy( void )
{
if ( DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() ) )
{
CHL1_Player *pPlayer = ToHL1Player( GetOwner() );
if ( pPlayer )
{
pPlayer->m_flPlayAftershock = 0.0;
}
return true;
}
else
{
return false;
}
}
bool CWeaponGauss::Holster( CBaseCombatWeapon *pSwitchingTo )
{
StopSpinSound();
m_nAttackState = 0;
return BaseClass::Holster(pSwitchingTo);
}
void CWeaponGauss::StopSpinSound( void )
{
if ( m_sndCharge != NULL )
{
(CSoundEnvelopeController::GetController()).SoundDestroy( m_sndCharge );
m_sndCharge = NULL;
}
}