//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponFrag::PrimaryAttack( void )
{
if ( m_bRedraw )
return;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
{
return;
}
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );;
if ( !pPlayer )
return;
// Note that this is a primary attack and prepare the grenade attack to pause.
m_AttackPaused = GRENADE_PAUSED_PRIMARY;
SendWeaponAnim( ACT_VM_PULLBACK_HIGH );
// Put both of these off indefinitely. We do not know how long
// the player will hold the grenade.
m_flTimeWeaponIdle = FLT_MAX;
m_flNextPrimaryAttack = FLT_MAX;
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
{
pPlayer->SwitchToNextBestWeapon( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Allows firing as fast as button is pressed
//-----------------------------------------------------------------------------
void CWeaponPistol::ItemPostFrame( void )
{
BaseClass::ItemPostFrame();
if ( m_bInReload )
return;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( pOwner == NULL )
return;
//Allow a refire as fast as the player can click
if ( ( ( pOwner->m_nButtons & IN_ATTACK ) == false ) && ( m_flSoonestPrimaryAttack < gpGlobals->curtime ) )
{
m_flNextPrimaryAttack = gpGlobals->curtime - 0.1f;
}
else if ( ( pOwner->m_nButtons & IN_ATTACK ) && ( m_flNextPrimaryAttack < gpGlobals->curtime ) && ( m_iClip1 <= 0 ) )
{
DryFire();
}
if ( HasPrimaryAmmo() )
{
p_laserSight->UpdateLaserPosition(this);
}
else
{
p_laserSight->TurnOff();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponShieldGrenade::PrimaryAttack( void )
{
CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
if ( !pPlayer )
return;
if ( !ComputeEMPFireState() )
return;
if ( !GetPrimaryAmmo() )
return;
// player "shoot" animation
PlayAttackAnimation( ACT_VM_THROW );
ThrowGrenade();
// Setup for refire
m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
CheckRemoveDisguise();
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
{
g_pGameRules->GetNextBestWeapon( pPlayer, NULL );
}
}
//DHL - Skillet - Fix ammo exploits
void CWeaponFrag::Drop( const Vector &vecVelocity )
{
if ( !HasPrimaryAmmo() )
{
//BaseClass::Drop( vecVelocity );
SUB_Remove();
return;
}
if ( !GetOwner() )
return;
DecrementAmmo( GetOwner() );
Reload(); //Do draw animation and stuff
#ifndef CLIENT_DLL
CBasePlayer *owner = ToBasePlayer(GetOwner());
Vector vThrowPos = owner->Weapon_ShootPosition() - Vector(0,0,12);
//Create a grenade
CBaseCombatWeapon* pGrenade;
pGrenade = (CBaseCombatWeapon *)CBaseEntity::Create( "weapon_frag", vThrowPos, vec3_angle, NULL );
if ( !pGrenade )
return;
pGrenade->SetRemoveable( true );
//If it was dropped then there's no need to respawn it.
pGrenade->AddSpawnFlags( SF_NORESPAWN );
pGrenade->StopAnimation();
pGrenade->StopFollowingEntity( );
pGrenade->SetMoveType( MOVETYPE_FLYGRAVITY );
// clear follow stuff, setup for collision
pGrenade->SetGravity(1.0);
pGrenade->m_iState = WEAPON_NOT_CARRIED;
pGrenade->RemoveEffects( EF_NODRAW );
pGrenade->FallInit();
pGrenade->SetGroundEntity( NULL );
pGrenade->SetTouch(NULL);
pGrenade->SetOwnerEntity( NULL );
pGrenade->SetOwner( NULL );
//Toss it in the direction of the player's view
Vector vecNewVelocity;
Vector vecDir;
owner->EyeVectors( &vecDir );
vecNewVelocity = ( vecDir * 500.0f );
IPhysicsObject *pObj = pGrenade->VPhysicsGetObject();
if ( pObj != NULL )
{
AngularImpulse angImp( 200, 200, 200 );
pObj->AddVelocity( &vecNewVelocity, &angImp );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponFrag::SecondaryAttack( void )
{
//DHL - Skillet - Disabled secondary attack
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
return;
if ( m_bRedraw )
return;
if ( !HasPrimaryAmmo() )
return;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return;
CBasePlayer *pPlayer = ToBasePlayer( pOwner );
if ( pPlayer == NULL )
return;
// Note that this is a secondary attack and prepare the grenade attack to pause.
m_AttackPaused = GRENADE_PAUSED_SECONDARY;
SendWeaponAnim( ACT_VM_PULLBACK_LOW );
// Don't let weapon idle interfere in the middle of a throw!
m_flTimeWeaponIdle = FLT_MAX;
m_flNextSecondaryAttack = FLT_MAX;
flPrimeTime = gpGlobals->curtime; //DHL: Grab the time we dropped the trigger
flExplodeTime = gpGlobals->curtime + GRENADE_TIMER; //DHL: We're going boom when this hits curtime
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
{
pPlayer->SwitchToNextBestWeapon( this );
}
}
bool CWeaponGrenade::Reload( void )
{
if ( !HasPrimaryAmmo() )
return false;
if ( m_bRedraw && m_flNextPrimaryAttack <= gpGlobals->curtime )
{
SendWeaponAnim( ACT_VM_DRAW );
m_flNextPrimaryAttack = m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
m_bRedraw = false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatLaserRifle::ItemPostFrame( void )
{
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if (!pOwner)
return;
if ( UsesClipsForAmmo1() )
{
CheckReload();
}
RecalculateAccuracy();
// Handle firing
if ( GetShieldState() == SS_DOWN && !m_bInReload )
{
if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
{
if ( m_iClip1 > 0 )
{
// Fire the plasma shot
PrimaryAttack();
}
else
{
Reload();
}
}
// Reload button (or fire button when we're out of ammo)
if ( m_flNextPrimaryAttack <= gpGlobals->curtime )
{
if ( pOwner->m_nButtons & IN_RELOAD )
{
Reload();
}
else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
{
if ( !m_iClip1 && HasPrimaryAmmo() )
{
Reload();
}
}
}
}
// Prevent shield post frame if we're not ready to attack, or we're charging
AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pOwner -
//-----------------------------------------------------------------------------
void CWeaponFrag::DecrementAmmo( CBaseCombatCharacter *pOwner )
{
pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
//DHL - Skillet - Once we throw our last grenade remove weapon_grenade from our inventory
#ifndef CLIENT_DLL
if ( !HasPrimaryAmmo() /*pOwner->GetAmmoCount( m_iPrimaryAmmoType ) <= 0*/ )
{
if ( GetLastWeapon() )
pOwner->SwitchToNextBestWeapon( this );
Drop( vec3_origin );
SUB_Remove();
}
#endif
}
void CWeaponGrenade::ItemPostFrame( void )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if (pOwner)
{
//Si on est pas en attente de lancer et que le nouton est appuyé
if(!m_bAttackPaused && (pOwner->m_nButtons & IN_ATTACK) && HasPrimaryAmmo() && gpGlobals->curtime > m_flNextPrimaryAttack)
PrimaryAttack();
//Sinon si on est en attente de lancer et que le bouton n'est plus appuyé
else if(m_bAttackPaused && !(pOwner->m_nButtons & IN_ATTACK))
PrimaryAttackThrow();
}
BaseClass::ItemPostFrame();
if ( m_bRedraw )
if ( IsViewModelSequenceFinished() )
Reload();
}
int CASW_Weapon::WeaponRangeAttack1Condition( float flDot, float flDist )
{
if (!IsOffensiveWeapon())
return COND_NO_WEAPON; // make sure the AI doesn't try to attack with this
if ( UsesPrimaryAmmo() && !HasPrimaryAmmo() )
{
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;
}
return COND_CAN_RANGE_ATTACK1;
}
void CWeaponGrenade::PrimaryAttackThrow( void ) {
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
return;
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );;
if ( !pPlayer )
return;
SendWeaponAnim( ACT_VM_THROW );
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
ThrowGrenade(pPlayer);
DecrementAmmo(pOwner);
m_bAttackPaused = false;
if(!HasPrimaryAmmo())
pPlayer->SwitchToNextBestWeapon( this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponFrag::Reload( void )
{
if ( !HasPrimaryAmmo() )
return false;
if ( ( m_bRedraw ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
{
//Redraw the weapon
SendWeaponAnim( ACT_VM_DRAW );
//Update our times
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
m_flNextSecondaryAttack = gpGlobals->curtime + SequenceDuration();
m_flTimeWeaponIdle = gpGlobals->curtime + SequenceDuration();
//Mark this as done
m_bRedraw = false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Base class always returns not bits
//-----------------------------------------------------------------------------
int CBaseCombatWeapon::WeaponRangeAttack1Condition( float flDot, float flDist )
{
if ( UsesPrimaryAmmo() && !HasPrimaryAmmo() )
{
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;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponHarpoon::PrimaryAttack( void )
{
CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
if ( !pPlayer )
return;
if ( !ComputeEMPFireState() )
return;
ThrowGrenade();
// Setup for refire
m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
CheckRemoveDisguise();
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
{
pPlayer->SelectLastItem();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponFrag::PrimaryAttack( void )
{
if ( m_bRedraw )
return;
CBaseCombatCharacter *pOwner = GetOwner();
if ( pOwner == NULL )
{
return;
}
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );;
if ( !pPlayer )
return;
// Note that this is a primary attack and prepare the grenade attack to pause.
m_AttackPaused = GRENADE_PAUSED_PRIMARY;
SendWeaponAnim( ACT_VM_PULLBACK_HIGH );
// Put both of these off indefinitely. We do not know how long
// the player will hold the grenade.
m_flTimeWeaponIdle = FLT_MAX;
m_flNextPrimaryAttack = FLT_MAX;
//DHL - Scale for slow motion
float flTimescale = DHLRules()->GetTimescale();
flGrenadeTimer = random->RandomFloat( 3.0f, 3.5f ) / flTimescale; //Randomize the fuse burn time
flPrimeTime = gpGlobals->curtime / flTimescale; //DHL: Grab the time we dropped the trigger
flExplodeTime = gpGlobals->curtime + flGrenadeTimer; //DHL: We're going boom when this hits curtime
//Warning( "Randomized fuse time is " 'flGrenadeTimer' "! \n");
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
{
pPlayer->SwitchToNextBestWeapon( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Prepare the grenade for throwing
//-----------------------------------------------------------------------------
void CGEWeaponGrenade::PrimaryAttack( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if (!pPlayer)
return;
// Note that this is a primary attack and prepare the grenade attack to pause.
m_bPreThrow = true;
SendWeaponAnim( ACT_VM_GRENADE_PULLPIN );
m_flNextReleaseTime = gpGlobals->curtime + SequenceDuration();
m_flPrimedTime = gpGlobals->curtime + GE_GRENADE_PIN_DELAY;
// Put both of these off indefinitely. We do not know how long
// the player will hold the grenade.
m_flTimeWeaponIdle = FLT_MAX;
m_flNextPrimaryAttack = FLT_MAX;
// If I'm now out of ammo, switch away
if ( !HasPrimaryAmmo() )
pPlayer->SwitchToNextBestWeapon( this );
}
void ItemPostFrame()
{
CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>(GetOwner());
if( !pPlayer )
return;
if ( pPlayer->m_afButtonReleased & IN_ATTACK )
{
CancelPrimaryAttack();
}
trace_t tr;
Vector eyePos, eyeForward;
pPlayer->EyePositionAndVectors( &eyePos, &eyeForward, NULL, NULL );
CTraceFilterSkipTwoEntities traceFilter( pPlayer, this, COLLISION_GROUP_NONE );
UTIL_TraceLine( eyePos, eyePos + eyeForward * MAX_TRACE_LENGTH, MASK_SHOT, &traceFilter, &tr );
if( !m_hBeam )
{
if ( gpGlobals->curtime >= m_flBeamTime )
{
#ifndef CLIENT_DLL
m_hBeam = CREATE_ENTITY( CBeam, "env_beam" );
if ( m_hBeam )
{
m_hBeam->BeamInit( "sprites/lgtning.vmt", 6.5f );
m_hBeam->PointEntInit( tr.endpos, pPlayer->GetViewModel(0) );
m_hBeam->SetScrollRate( -10.f );
m_hBeam->SetNoise( 1 );
m_hBeam->SetEndAttachment( LookupAttachment("muzzle") );
m_hBeam->Spawn();
}
#endif
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
}
if ( m_flBeamTime == FLT_MAX )
BaseClass::ItemPostFrame();
}
else
{
if ( gpGlobals->curtime >= m_flDamageTime )
{
GetOwner()->RemoveAmmo( 1, GetPrimaryAmmoType() );
#ifndef CLIENT_DLL
if( tr.fraction != 1.0 && tr.m_pEnt )
{
ClearMultiDamage();
Vector dir = tr.endpos - m_hBeam->GetAbsEndPos();
VectorNormalize( dir );
const float flDamage = BEAM_DAMAGE;
CTakeDamageInfo info( m_hBeam, GetOwner(), flDamage, DMG_SHOCK );
CalculateMeleeDamageForce( &info, dir, tr.endpos );
tr.m_pEnt->DispatchTraceAttack( info, dir, &tr );
ApplyMultiDamage();
RadiusDamage( CTakeDamageInfo( m_hBeam, GetOwner(), flDamage * 0.25f, DMG_SHOCK ), tr.endpos, 16.0f, CLASS_NONE, NULL );
}
#endif
if ( !HasPrimaryAmmo() )
CancelPrimaryAttack();
m_flDamageTime = gpGlobals->curtime + DAMAGE_TICK;
}
m_hBeam->SetStartPos( tr.endpos );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponFrag::ItemPostFrame( void )
{
#ifdef MFS
if (!HasPrimaryAmmo())
weight = 0;
else if (GetPrimaryAmmoCount() == 1 )
weight = 0.5;
else if (GetPrimaryAmmoCount() == 2)
weight = 1;
else if (GetPrimaryAmmoCount() == 3)
weight = 1.5;
else if (GetPrimaryAmmoCount() == 4)
weight = 2;
else if (GetPrimaryAmmoCount() == 5)
weight = 2.5;
else if (GetPrimaryAmmoCount() == 6)
weight = 3;
#endif
if( m_fDrawbackFinished )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if (pOwner)
{
switch( m_AttackPaused )
{
case GRENADE_PAUSED_PRIMARY:
if( !(pOwner->m_nButtons & IN_ATTACK) )
{
SendWeaponAnim( ACT_VM_THROW );
m_fDrawbackFinished = false;
}
break;
case GRENADE_PAUSED_SECONDARY:
if( !(pOwner->m_nButtons & IN_ATTACK2) )
{
//See if we're ducking
if ( pOwner->m_nButtons & IN_DUCK )
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
}
else
{
//Send the weapon animation
SendWeaponAnim( ACT_VM_HAULBACK );
}
m_fDrawbackFinished = false;
}
break;
default:
break;
}
}
}
BaseClass::ItemPostFrame();
if ( m_bRedraw )
{
if ( IsViewModelSequenceFinished() )
{
Reload();
}
}
}
