mirror of
https://github.com/Gigaslav/HL2Overcharged.git
synced 2026-09-04 11:44:45 +03:00
625 lines
17 KiB
C++
625 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "basehlcombatweapon.h"
|
|
#include "soundent.h"
|
|
#include "ai_basenpc.h"
|
|
#include "game.h"
|
|
#include "in_buttons.h"
|
|
#include "gamestats.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
IMPLEMENT_SERVERCLASS_ST( CHLMachineGun, DT_HLMachineGun )
|
|
END_SEND_TABLE()
|
|
|
|
//=========================================================
|
|
// >> CHLSelectFireMachineGun
|
|
//=========================================================
|
|
BEGIN_DATADESC( CHLMachineGun )
|
|
|
|
DEFINE_FIELD( m_nShotsFired, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flNextSoundTime, FIELD_TIME ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CHLMachineGun::CHLMachineGun( void )
|
|
{
|
|
ChangeOnce = true;
|
|
}
|
|
|
|
const Vector &CHLMachineGun::GetBulletSpread( void )
|
|
{
|
|
if (GetOwner() && GetOwner()->IsPlayer())
|
|
{
|
|
static Vector spread;
|
|
if (GetOwner()->GetActiveWeapon())
|
|
{
|
|
if ((GetOwner()->GetFlags() & FL_DUCKING) != 0)
|
|
{
|
|
if (IsIronSighted())
|
|
{
|
|
spread.x = GetWpnData().irSightSpread;
|
|
spread.y = GetWpnData().irSightSpread;
|
|
spread.z = GetWpnData().irSightSpread;
|
|
}
|
|
else if (IsScopeSighted())
|
|
{
|
|
spread.x = GetWpnData().ScopeSightSpread;
|
|
spread.y = GetWpnData().ScopeSightSpread;
|
|
spread.z = GetWpnData().ScopeSightSpread;
|
|
}
|
|
else
|
|
{
|
|
spread.x = GetWpnData().crouchSpread;
|
|
spread.y = GetWpnData().crouchSpread;
|
|
spread.z = GetWpnData().crouchSpread;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GetOwnerIsRunning())//(cvar->FindVar("oc_state_player_velocity")->GetFloat() >= 10 && cvar->FindVar("oc_state_player_velocity")->GetFloat() > cvar->FindVar("hl2_normspeed")->GetFloat() + 50.f)
|
|
{
|
|
spread.x = GetWpnData().runningSpread;
|
|
spread.y = GetWpnData().runningSpread;
|
|
spread.z = GetWpnData().runningSpread;
|
|
}
|
|
else if (!GetOwnerIsRunning() && cvar->FindVar("oc_state_player_velocity")->GetFloat() >= 50.f)//(cvar->FindVar("oc_state_player_velocity")->GetFloat() >= 10 && cvar->FindVar("oc_state_player_velocity")->GetFloat() <= cvar->FindVar("hl2_normspeed")->GetFloat())
|
|
{
|
|
if (IsIronSighted())
|
|
{
|
|
spread.x = GetWpnData().irSightSpread;
|
|
spread.y = GetWpnData().irSightSpread;
|
|
spread.z = GetWpnData().irSightSpread;
|
|
}
|
|
else if (IsScopeSighted())
|
|
{
|
|
spread.x = GetWpnData().ScopeSightSpread;
|
|
spread.y = GetWpnData().ScopeSightSpread;
|
|
spread.z = GetWpnData().ScopeSightSpread;
|
|
}
|
|
else
|
|
{
|
|
spread.x = GetWpnData().walkingSpread;
|
|
spread.y = GetWpnData().walkingSpread;
|
|
spread.z = GetWpnData().walkingSpread;
|
|
}
|
|
}
|
|
else if (!GetOwnerIsRunning() && cvar->FindVar("oc_state_player_velocity")->GetFloat() < 50.f)
|
|
{
|
|
if (IsIronSighted())
|
|
{
|
|
spread.x = GetWpnData().irSightSpread;
|
|
spread.y = GetWpnData().irSightSpread;
|
|
spread.z = GetWpnData().irSightSpread;
|
|
}
|
|
else if (IsScopeSighted())
|
|
{
|
|
spread.x = GetWpnData().ScopeSightSpread;
|
|
spread.y = GetWpnData().ScopeSightSpread;
|
|
spread.z = GetWpnData().ScopeSightSpread;
|
|
}
|
|
else
|
|
{
|
|
spread.x = GetWpnData().standingSpread;
|
|
spread.y = GetWpnData().standingSpread;
|
|
spread.z = GetWpnData().standingSpread;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return spread;
|
|
}
|
|
else if (GetOwner() && GetOwner()->IsNPC())
|
|
{
|
|
static Vector spread;
|
|
if (GetOwner()->GetActiveWeapon())
|
|
{
|
|
if ((GetOwner()->GetFlags() & FL_DUCKING) != 0)
|
|
{
|
|
spread.x = GetWpnData().crouchSpreadNpc;
|
|
spread.y = GetWpnData().crouchSpreadNpc;
|
|
spread.z = GetWpnData().crouchSpreadNpc;
|
|
}
|
|
else
|
|
{
|
|
if (GetOwner()->m_flSpeed > 0)
|
|
{
|
|
spread.x = GetWpnData().runningSpreadNpc;
|
|
spread.y = GetWpnData().runningSpreadNpc;
|
|
spread.z = GetWpnData().runningSpreadNpc;
|
|
}
|
|
/*else if (cvar->FindVar("oc_state_player_velocity")->GetFloat() >= 10 && cvar->FindVar("oc_state_player_velocity")->GetFloat() <= cvar->FindVar("hl2_normspeed")->GetFloat())
|
|
{
|
|
spread.x = GetOwner()->GetActiveWeapon()->GetWpnData().walkingSpread;
|
|
spread.y = GetOwner()->GetActiveWeapon()->GetWpnData().walkingSpread;
|
|
spread.z = GetOwner()->GetActiveWeapon()->GetWpnData().walkingSpread;
|
|
}*/
|
|
else if (GetOwner()->m_flSpeed <= 0)
|
|
{
|
|
spread.x = GetWpnData().standingSpreadNpc;
|
|
spread.y = GetWpnData().standingSpreadNpc;
|
|
spread.z = GetWpnData().standingSpreadNpc;
|
|
}
|
|
}
|
|
}
|
|
return spread;
|
|
}
|
|
|
|
static Vector cone = VECTOR_CONE_3DEGREES;
|
|
return cone;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CHLMachineGun::PrimaryAttack( void )
|
|
{
|
|
BaseClass::PrimaryAttack();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &info -
|
|
//-----------------------------------------------------------------------------
|
|
void CHLMachineGun::FireBullets( const FireBulletsInfo_t &info )
|
|
{
|
|
if(CBasePlayer *pPlayer = ToBasePlayer ( GetOwner() ) )
|
|
{
|
|
pPlayer->FireBullets(info);
|
|
}
|
|
}
|
|
void CHLMachineGun::FireBulletsShotgun(const FireBulletsInfo_t &info)
|
|
{
|
|
if (CBasePlayer *pPlayer = ToBasePlayer(GetOwner()))
|
|
{
|
|
pPlayer->FireBulletsShotgun(info);
|
|
}
|
|
}
|
|
void CHLMachineGun::FireBulletsVehicle(const FireBulletsInfo_t &info)
|
|
{
|
|
if (CBasePlayer *pPlayer = ToBasePlayer(GetOwner()))
|
|
{
|
|
pPlayer->FireBulletsVehicle(info);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Weapon firing conditions
|
|
//-----------------------------------------------------------------------------
|
|
int CHLMachineGun::WeaponRangeAttack1Condition( float flDot, float flDist )
|
|
{
|
|
if ( m_iClip1 <=0 )
|
|
{
|
|
return COND_NO_PRIMARY_AMMO;
|
|
}
|
|
else if ( flDist < m_fMinRange1 )
|
|
{
|
|
return COND_TOO_CLOSE_TO_ATTACK;
|
|
}
|
|
else if ( flDist > m_fMaxRange1 )
|
|
{
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
else if ( flDot < 0.5f ) // UNDONE: Why check this here? Isn't the AI checking this already?
|
|
{
|
|
return COND_NOT_FACING_ATTACK;
|
|
}
|
|
|
|
return COND_CAN_RANGE_ATTACK1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CHLMachineGun::DoMachineGunKick( CBasePlayer *pPlayer, float dampEasy, float maxVerticleKickAngle, float fireDurationTime, float slideLimitTime )
|
|
{
|
|
#define KICK_MIN_X 0.2f //Degrees
|
|
#define KICK_MIN_Y 0.2f //Degrees
|
|
#define KICK_MIN_Z 0.1f //Degrees
|
|
|
|
QAngle vecScratch;
|
|
|
|
//Find how far into our accuracy degradation we are
|
|
float duration = ( fireDurationTime > slideLimitTime ) ? slideLimitTime : fireDurationTime;
|
|
float kickPerc = duration / slideLimitTime;
|
|
|
|
// do this to get a hard discontinuity, clear out anything under 10 degrees punch
|
|
pPlayer->ViewPunchReset( 10 );
|
|
|
|
//Apply this to the view angles as well
|
|
vecScratch.x = -( KICK_MIN_X + ( maxVerticleKickAngle * kickPerc ) );
|
|
vecScratch.y = -( KICK_MIN_Y + ( maxVerticleKickAngle * kickPerc ) ) / 3;
|
|
vecScratch.z = KICK_MIN_Z + ( maxVerticleKickAngle * kickPerc ) / 8;
|
|
|
|
//Wibble left and right
|
|
if ( random->RandomInt( -1, 1 ) >= 0 )
|
|
vecScratch.y *= -1;
|
|
|
|
//Wobble up and down
|
|
if ( random->RandomInt( -1, 1 ) >= 0 )
|
|
vecScratch.z *= -1;
|
|
|
|
//If we're in easy, dampen the effect a bit
|
|
if ( g_pGameRules->IsSkillLevel( SKILL_EASY ) )
|
|
{
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
vecScratch[i] *= dampEasy;
|
|
}
|
|
}
|
|
|
|
//Clip this to our desired min/max
|
|
UTIL_ClipPunchAngleOffset( vecScratch, pPlayer->m_Local.m_vecPunchAngle, QAngle( 24.0f, 3.0f, 1.0f ) );
|
|
|
|
//Add it to the view punch
|
|
// NOTE: 0.5 is just tuned to match the old effect before the punch became simulated
|
|
pPlayer->ViewPunch( vecScratch * 0.5 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reset our shots fired
|
|
//-----------------------------------------------------------------------------
|
|
bool CHLMachineGun::Deploy( void )
|
|
{
|
|
m_nShotsFired = 0;
|
|
|
|
return BaseClass::Deploy();
|
|
}
|
|
bool CHLMachineGun::FirstDeploy(int iActivity)
|
|
{
|
|
m_nShotsFired = 0;
|
|
return BaseClass::FirstDeploy(iActivity);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Make enough sound events to fill the estimated think interval
|
|
// returns: number of shots needed
|
|
//-----------------------------------------------------------------------------
|
|
int CHLMachineGun::WeaponSoundRealtime( WeaponSound_t shoot_type )
|
|
{
|
|
int numBullets = 0;
|
|
|
|
// ran out of time, clamp to current
|
|
if (m_flNextSoundTime < gpGlobals->curtime)
|
|
{
|
|
m_flNextSoundTime = gpGlobals->curtime;
|
|
}
|
|
|
|
// make enough sound events to fill up the next estimated think interval
|
|
float dt = clamp( m_flAnimTime - m_flPrevAnimTime, 0, 0.2 );
|
|
if (m_flNextSoundTime < gpGlobals->curtime + dt)
|
|
{
|
|
WeaponSound( SINGLE_NPC, m_flNextSoundTime );
|
|
m_flNextSoundTime += GetFireRate();
|
|
numBullets++;
|
|
}
|
|
if (m_flNextSoundTime < gpGlobals->curtime + dt)
|
|
{
|
|
WeaponSound( SINGLE_NPC, m_flNextSoundTime );
|
|
m_flNextSoundTime += GetFireRate();
|
|
numBullets++;
|
|
}
|
|
|
|
return numBullets;
|
|
}
|
|
|
|
|
|
|
|
bool DoOnceM = true;
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CHLMachineGun::ItemPostFrame(void)
|
|
{
|
|
CBasePlayer *pOwner = ToBasePlayer(GetOwner());
|
|
|
|
if (pOwner == NULL)
|
|
return;
|
|
|
|
// Debounce the recoiling counter
|
|
if ((pOwner->m_nButtons & IN_ATTACK) == false)
|
|
{
|
|
m_nShotsFired = 0;
|
|
}
|
|
|
|
BaseClass::ItemPostFrame();
|
|
}
|
|
|
|
IMPLEMENT_SERVERCLASS_ST( CHLSelectFireMachineGun, DT_HLSelectFireMachineGun )
|
|
END_SEND_TABLE()
|
|
|
|
//=========================================================
|
|
// >> CHLSelectFireMachineGun
|
|
//=========================================================
|
|
BEGIN_DATADESC( CHLSelectFireMachineGun )
|
|
|
|
DEFINE_FIELD( m_iBurstSize, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iFireMode, FIELD_INTEGER ),
|
|
|
|
// Function pinters
|
|
DEFINE_FUNCTION( BurstThink ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
|
|
float CHLSelectFireMachineGun::GetBurstCycleRate( void )
|
|
{
|
|
// this is the time it takes to fire an entire
|
|
// burst, plus whatever amount of delay we want
|
|
// to have between bursts.
|
|
return 0.5f;
|
|
}
|
|
|
|
float CHLSelectFireMachineGun::GetFireRate( void )
|
|
{
|
|
return BaseClass::GetFireRate();
|
|
}
|
|
|
|
bool CHLSelectFireMachineGun::Deploy( void )
|
|
{
|
|
// Forget about any bursts this weapon was firing when holstered
|
|
m_iBurstSize = 0;
|
|
return BaseClass::Deploy();
|
|
}
|
|
bool CHLSelectFireMachineGun::FirstDeploy(int iActivity)
|
|
{
|
|
// Forget about any bursts this weapon was firing when holstered
|
|
m_iBurstSize = 0;
|
|
return BaseClass::FirstDeploy(iActivity);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CHLSelectFireMachineGun::PrimaryAttack( void )
|
|
{
|
|
/*if (m_bFireOnEmpty)
|
|
{
|
|
return;
|
|
}
|
|
switch( m_iFireMode )
|
|
{
|
|
case FIREMODE_FULLAUTO:
|
|
BaseClass::PrimaryAttack();
|
|
// Msg("%.3f\n", m_flNextPrimaryAttack.Get() );
|
|
SetWeaponIdleTime( gpGlobals->curtime + 3.0f );
|
|
break;
|
|
|
|
case FIREMODE_ALYXGUN_AUTO://OverCharged
|
|
// BaseClass::PrimaryAttack();//OverCharged
|
|
// Msg("%.3f\n", m_flNextPrimaryAttack.Get() );
|
|
// SetWeaponIdleTime(gpGlobals->curtime + 3.0f);
|
|
break;
|
|
|
|
case FIREMODE_3RNDBURST:
|
|
m_iBurstSize = GetBurstSize();
|
|
|
|
// Call the think function directly so that the first round gets fired immediately.
|
|
BurstThink();
|
|
SetThink( &CHLSelectFireMachineGun::BurstThink );
|
|
m_flNextPrimaryAttack = gpGlobals->curtime + GetBurstCycleRate();
|
|
m_flNextSecondaryAttack = gpGlobals->curtime + GetBurstCycleRate();
|
|
|
|
// Pick up the rest of the burst through the think function.
|
|
SetNextThink( gpGlobals->curtime + GetFireRate() );
|
|
break;
|
|
}
|
|
|
|
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
|
|
if ( pOwner )
|
|
{
|
|
m_iPrimaryAttacks++;
|
|
gamestats->Event_WeaponFired( pOwner, true, GetClassname() );
|
|
}
|
|
|
|
AddViewKick();*/
|
|
|
|
BaseClass::PrimaryAttack();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CHLSelectFireMachineGun::SecondaryAttack( void )
|
|
{
|
|
// change fire modes.
|
|
|
|
CBasePlayer *pOwner = ToBasePlayer(GetOwner());
|
|
switch( m_iFireMode )
|
|
{
|
|
case FIREMODE_FULLAUTO:
|
|
//Msg( "Burst\n" );
|
|
m_iFireMode = FIREMODE_3RNDBURST;
|
|
WeaponSound(SPECIAL2);
|
|
if (pOwner)
|
|
UTIL_ShowMessage("WPN_BURST", pOwner); // BriJee OVR: New ingame notifications
|
|
break;
|
|
|
|
case FIREMODE_3RNDBURST:
|
|
//Msg( "Auto\n" );
|
|
m_iFireMode = FIREMODE_FULLAUTO;
|
|
WeaponSound(SPECIAL1);
|
|
if (pOwner)
|
|
UTIL_ShowMessage("WPN_FULLAUTO", pOwner);
|
|
break;
|
|
}
|
|
|
|
SendWeaponAnim( GetSecondaryAttackActivity() );
|
|
|
|
m_flNextSecondaryAttack = gpGlobals->curtime + 1.3; // BriJee OVR: Adjust time between modes!
|
|
|
|
/*if (pOwner && ((m_iClip2 <= (GetMaxClip2() / 4)) && m_iClip2 != 0 && m_iClip2 <= 2))
|
|
WeaponSound(LOW_AMMO);*/
|
|
|
|
//CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
|
|
if ( pOwner )
|
|
{
|
|
m_iSecondaryAttacks++;
|
|
gamestats->Event_WeaponFired( pOwner, false, GetClassname() );
|
|
}
|
|
|
|
AddViewKick();
|
|
|
|
/*if (pOwner->GetActiveWeapon() && pOwner->GetActiveWeapon()->GetWpnData().iMuzzleFlashTypeS != NULL)
|
|
{
|
|
int ind = random->RandomInt(1, pOwner->GetActiveWeapon()->GetWpnData().externalIndexS);
|
|
char prclName2[256];
|
|
Q_snprintf(prclName2, sizeof(prclName2), "%s", pOwner->GetActiveWeapon()->GetWpnData().iMuzzleFlashTypeS[ind]);
|
|
char prclAName2[256];
|
|
Q_snprintf(prclAName2, sizeof(prclAName2), "%s", pOwner->GetActiveWeapon()->GetWpnData().iSecondaryAttachment);
|
|
|
|
DispatchParticleEffect(prclName2, PATTACH_POINT_FOLLOW, pOwner->GetViewModel(), prclAName2, false);
|
|
}*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CHLSelectFireMachineGun::BurstThink( void )
|
|
{
|
|
CHLMachineGun::PrimaryAttack();
|
|
|
|
m_iBurstSize--;
|
|
|
|
if( m_iBurstSize == 0 )
|
|
{
|
|
// The burst is over!
|
|
SetThink(NULL);
|
|
|
|
// idle immediately to stop the firing animation
|
|
SetWeaponIdleTime( gpGlobals->curtime );
|
|
return;
|
|
}
|
|
|
|
SetNextThink( gpGlobals->curtime + GetFireRate() );
|
|
}
|
|
|
|
void CHLSelectFireMachineGun::BurstThink2(void)
|
|
{
|
|
CHLMachineGun::PrimaryAttack();
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CHLSelectFireMachineGun::WeaponSound( WeaponSound_t shoot_type, float soundtime /*= 0.0f*/ )
|
|
{
|
|
if (shoot_type == SINGLE)
|
|
{
|
|
switch( m_iFireMode )
|
|
{
|
|
case FIREMODE_FULLAUTO:
|
|
{
|
|
BaseClass::WeaponSound(SINGLE, soundtime);
|
|
}
|
|
break;
|
|
|
|
case FIREMODE_3RNDBURST:
|
|
BaseClass::WeaponSound(WPN_DOUBLE, soundtime);//OverCharged
|
|
if( m_iBurstSize == GetBurstSize() && m_iClip1 >= m_iBurstSize )
|
|
{
|
|
// First round of a burst, and enough bullets remaining in the clip to fire the whole burst
|
|
BaseClass::WeaponSound( BURST, soundtime );
|
|
}
|
|
else if( m_iClip1 < m_iBurstSize )
|
|
{
|
|
//if (m_iClip1 <= GetMaxClip1() / 4 && m_iClip1 <= 8)
|
|
//WeaponSound(LOW_AMMO, soundtime);
|
|
// Not enough rounds remaining in the magazine to fire a burst, so play the gunshot
|
|
// sounds individually as each round is fired.
|
|
BaseClass::WeaponSound( SINGLE, soundtime );
|
|
}
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
BaseClass::WeaponSound( shoot_type, soundtime );
|
|
}
|
|
|
|
// BUGBUG: These need to be rethought
|
|
//-----------------------------------------------------------------------------
|
|
int CHLSelectFireMachineGun::WeaponRangeAttack1Condition( float flDot, float flDist )
|
|
{
|
|
if (m_iClip1 <=0)
|
|
{
|
|
return COND_NO_PRIMARY_AMMO;
|
|
}
|
|
else if ( flDist < m_fMinRange1)
|
|
{
|
|
return COND_TOO_CLOSE_TO_ATTACK;
|
|
}
|
|
else if (flDist > m_fMaxRange1)
|
|
{
|
|
return COND_TOO_FAR_TO_ATTACK;
|
|
}
|
|
else if (flDot < 0.5) // UNDONE: Why check this here? Isn't the AI checking this already?
|
|
{
|
|
return COND_NOT_FACING_ATTACK;
|
|
}
|
|
|
|
return COND_CAN_RANGE_ATTACK1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int CHLSelectFireMachineGun::WeaponRangeAttack2Condition( float flDot, float flDist )
|
|
{
|
|
return COND_NONE; // FIXME: disabled for now
|
|
|
|
// m_iClip2 == -1 when no secondary clip is used
|
|
if ( m_iClip2 == 0 && UsesSecondaryAmmo() )
|
|
{
|
|
return COND_NO_SECONDARY_AMMO;
|
|
}
|
|
else if ( flDist < m_fMinRange2 )
|
|
{
|
|
// Don't return COND_TOO_CLOSE_TO_ATTACK only for primary attack
|
|
return COND_NONE;
|
|
}
|
|
else if (flDist > m_fMaxRange2 )
|
|
{
|
|
// Don't return COND_TOO_FAR_TO_ATTACK only for primary attack
|
|
return COND_NONE;
|
|
}
|
|
else if ( flDot < 0.5 ) // UNDONE: Why check this here? Isn't the AI checking this already?
|
|
{
|
|
return COND_NOT_FACING_ATTACK;
|
|
}
|
|
|
|
return COND_CAN_RANGE_ATTACK2;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CHLSelectFireMachineGun::CHLSelectFireMachineGun( void )
|
|
{
|
|
m_fMinRange1 = 65;
|
|
m_fMinRange2 = 65;
|
|
m_fMaxRange1 = 1024;
|
|
m_fMaxRange2 = 1024;
|
|
m_iFireMode = FIREMODE_FULLAUTO;
|
|
}
|